MCMCInterval * Tprime::GetMcmcInterval(ModelConfig mc,
double conf_level,
int n_iter,
int n_burn,
double left_side_tail_fraction,
int n_bins) {
//
// Bayesian MCMC calculation using arbitrary ModelConfig
// Want an efficient proposal function, so derive it from covariance
// matrix of fit
//
RooAbsData * _data = data;
//RooAbsData * _data = pWs->data("obsData");
//RooStats::ModelConfig * _mc = (RooStats::ModelConfig *)pWs->genobj("ModelConfig");
RooStats::ModelConfig * _mc = GetModelConfig();
_mc->Print();
//RooFitResult * fit = pWs->pdf("model_tprime")->fitTo(*_data,Save());
RooFitResult * fit = _mc->GetPdf()->fitTo(*_data,Save());
ProposalHelper ph;
ph.SetVariables((RooArgSet&)fit->floatParsFinal());
ph.SetCovMatrix(fit->covarianceMatrix());
ph.SetUpdateProposalParameters(kTRUE); // auto-create mean vars and add mappings
ph.SetCacheSize(100);
ProposalFunction * pf = ph.GetProposalFunction();
//delete pf;
//pf = new SequentialProposal();
MCMCCalculator mcmc( *_data, mc );
mcmc.SetConfidenceLevel(conf_level);
mcmc.SetNumIters(n_iter); // Metropolis-Hastings algorithm iterations
mcmc.SetProposalFunction(*pf);
mcmc.SetNumBurnInSteps(n_burn); // first N steps to be ignored as burn-in
mcmc.SetLeftSideTailFraction(left_side_tail_fraction);
mcmc.SetNumBins(n_bins);
//mcInt = mcmc.GetInterval();
try {
mcInt = mcmc.GetInterval();
} catch ( std::length_error &ex) {
mcInt = 0;
}
//std::cout << "!!!!!!!!!!!!!! interval" << std::endl;
if (mcInt == 0) std::cout << "No interval found!" << std::endl;
delete fit;
delete pf;
return mcInt;
}
void printResult(){
if (fitresult!=NULL){
printf("%s\n",
"==================================================+++" );
fitresult->Print("v") ;
fitresult->floatParsFinal().Print("s") ;
printf("%s\nfit range: %5.1f %5.1f\n",
"==================================================+++",
min, max );
//RooRealVar* par1_fitresult = (RooRealVar*) fitresult->floatParsFinal()->find("par1")
//par1_fitresult->GetAsymErrorHi() ; // etc...
}
}//printResult
MCMCInterval * TwoBody::GetMcmcInterval_OldWay(ModelConfig mc,
double conf_level,
int n_iter,
int n_burn,
double left_side_tail_fraction,
int n_bins){
// use MCMCCalculator (takes about 1 min)
// Want an efficient proposal function, so derive it from covariance
// matrix of fit
RooFitResult* fit = ws->pdf("model")->fitTo(*data,Save());
ProposalHelper ph;
ph.SetVariables((RooArgSet&)fit->floatParsFinal());
ph.SetCovMatrix(fit->covarianceMatrix());
ph.SetUpdateProposalParameters(kTRUE); // auto-create mean vars and add mappings
ph.SetCacheSize(100);
ProposalFunction* pf = ph.GetProposalFunction();
MCMCCalculator mcmc( *data, mc );
mcmc.SetConfidenceLevel(conf_level);
mcmc.SetNumIters(n_iter); // Metropolis-Hastings algorithm iterations
mcmc.SetProposalFunction(*pf);
mcmc.SetNumBurnInSteps(n_burn); // first N steps to be ignored as burn-in
mcmc.SetLeftSideTailFraction(left_side_tail_fraction);
mcmc.SetNumBins(n_bins);
//mcInt = mcmc.GetInterval();
try {
mcInt = mcmc.GetInterval();
} catch ( std::length_error &ex) {
mcInt = 0;
}
//std::cout << "!!!!!!!!!!!!!! interval" << std::endl;
if (mcInt == 0) std::cout << "No interval found!" << std::endl;
return mcInt;
}
///
/// Fit a pdf to the minimum, but keep angular parameters in a range of
/// [0,2pi]. If after an initial fit, a parameter has walked outside this
/// interval, add multiples of 2pi to bring it back. Then, refit.
/// All variables that have unit 'rad' are taken to be angles.
///
RooFitResult* Utils::fitToMinBringBackAngles(RooAbsPdf *pdf, bool thorough, int printLevel)
{
countAllFitBringBackAngle++;
RooFitResult* r = fitToMin(pdf, thorough, printLevel);
bool refit = false;
TIterator* it = r->floatParsFinal().createIterator();
while ( RooRealVar* p = (RooRealVar*)it->Next() ){
if ( ! isAngle(p) ) continue;
if ( p->getVal()<0.0 || p->getVal()>2.*TMath::Pi() ){
RooArgSet *pdfPars = pdf->getParameters(RooArgSet());
RooRealVar *pdfPar = (RooRealVar*)pdfPars->find(p->GetName());
pdfPar->setVal(bringBackAngle(p->getVal()));
refit = true;
delete pdfPars;
}
}
if ( refit ){
countFitBringBackAngle++;
delete r;
r = fitToMin(pdf, thorough, printLevel);
}
delete it;
return r;
}
void Fit3D::plotFitProjection(
const RooRealVar &independant_variable,
const RooDataSet &data,
const RooFitResult& fit,
const RooAbsPdf &model,
const RooAbsPdf &bs_pdf,
const RooAbsPdf &bd_pdf,
const RooAbsPdf &cw_pdf,
const RooAbsPdf &ww_pdf,
const RooAbsPdf &cn_pdf,
const TString &filename)
{
RooPlot* frame = independant_variable.frame();
TString frame_title = "Fit Projection on ";
frame_title.Append(independant_variable.GetTitle());
frame->SetTitle(frame_title);
RooRealVar* bs_fit = (RooRealVar*) fit.floatParsFinal().find("n_bs_pp");
RooRealVar* bd_fit = (RooRealVar*) fit.floatParsFinal().find("n_bd_pp");
RooRealVar* cw_fit = (RooRealVar*) fit.floatParsFinal().find("n_cw_pp");
RooRealVar* ww_fit = (RooRealVar*) fit.floatParsFinal().find("n_ww_pp");
RooRealVar* cn_fit = (RooRealVar*) fit.floatParsFinal().find("n_cn_pp");
if (!bs_fit) {
bs_fit = (RooRealVar*) fit.floatParsFinal().find("n_bs_nn");
bd_fit = (RooRealVar*) fit.floatParsFinal().find("n_bd_nn");
cw_fit = (RooRealVar*) fit.floatParsFinal().find("n_cw_nn");
ww_fit = (RooRealVar*) fit.floatParsFinal().find("n_ww_nn");
cn_fit = (RooRealVar*) fit.floatParsFinal().find("n_cn_nn");
}
if (!bs_fit) {
// Error. Quit while ahead.
cout << "Error in plotFitAccuracy(): "
<< "Cannot find fit variables. Check names are valid."
<< endl;
return;
}
data.plotOn(frame, RooFit::Name("data"));
// model.plotOn(frame, RooFit::Name("model"), RooFit::LineColor(kBlue));
bs_pdf.plotOn(frame,
RooFit::Normalization(bs_fit->getVal(), RooAbsReal::NumEvent),
RooFit::LineStyle(kDashed),
RooFit::LineWidth(1),
RooFit::LineColor(kYellow + 2));
data.plotOn(frame, RooFit::Cut(bs_events_cut_),
RooFit::LineColor(kYellow),
RooFit::MarkerStyle(kFullDotMedium));
bd_pdf.plotOn(frame,
RooFit::Normalization(bd_fit->getVal(), RooAbsReal::NumEvent),
RooFit::LineStyle(kDashed),
RooFit::LineWidth(1),
RooFit::LineColor(kRed + 2));
data.plotOn(frame, RooFit::Cut(bd_events_cut_),
RooFit::LineColor(kRed),
RooFit::MarkerStyle(kFullDotMedium));
cw_pdf.plotOn(frame,
RooFit::Normalization(cw_fit->getVal(), RooAbsReal::NumEvent),
RooFit::LineStyle(kDashed),
RooFit::LineWidth(1),
RooFit::LineColor(kGreen + 2));
data.plotOn(frame, RooFit::Cut(cw_events_cut_),
RooFit::LineColor(kGreen),
RooFit::MarkerStyle(kFullDotMedium));
ww_pdf.plotOn(frame,
RooFit::Normalization(ww_fit->getVal(), RooAbsReal::NumEvent),
RooFit::LineStyle(kDashed),
RooFit::LineWidth(1),
RooFit::LineColor(kBlue + 2));
data.plotOn(frame, RooFit::Cut(ww_events_cut_),
RooFit::LineColor(kBlue),
RooFit::MarkerStyle(kFullDotMedium));
cn_pdf.plotOn(frame,
RooFit::Normalization(cn_fit->getVal(), RooAbsReal::NumEvent),
RooFit::LineStyle(kDashed),
RooFit::LineWidth(1),
RooFit::LineColor(kCyan + 2));
data.plotOn(frame, RooFit::Cut(cn_events_cut_),
RooFit::LineColor(kCyan),
RooFit::MarkerStyle(kFullDotMedium));
TCanvas* c1 = new TCanvas("c1", "Projection", 200, 10, 700, 500);
frame->Draw();
c1->Print(output_path_ + filename);
}
void embeddedToysVBF_1DKD(int nEvts=50, int nToys=100,
sample mySample = kScalar_fa3_0){
RooRealVar* kd = new RooRealVar("psMELA","psMELA",0,1);
kd->setBins(50);
RooPlot* kdframe1 = kd->frame();
// 0- template
TFile f1("ggH2j_KDdistribution_ps.root", "READ");
TH2F *h_KD_ps = (TH2F*)f1.Get("h_KD");
h_KD_ps->SetName("h_KD_ps");
RooDataHist rdh_KD_ps("rdh_KD_ps","rdh_KD_ps",RooArgList(*kd),h_KD_ps);
RooHistPdf pdf_KD_ps("pdf_KD_ps","pdf_KD_ps",RooArgList(*kd),rdh_KD_ps);
// 0+ template
TFile f2("ggH2j_KDdistribution_sm.root", "READ");
TH2F *h_KD_sm = (TH2F*)f2.Get("h_KD");
h_KD_sm->SetName("h_KD_sm");
RooDataHist rdh_KD_sm("rdh_KD_sm","rdh_KD_sm",RooArgList(*kd),h_KD_sm);
RooHistPdf pdf_KD_sm("pdf_KD_sm","pdf_KD_sm",RooArgList(*kd),rdh_KD_sm);
RooRealVar rrv_fa3("fa3","fa3",0.5,0.,1.); //free parameter of the model
RooAddPdf model("model","ps+sm",pdf_KD_ps,pdf_KD_sm,rrv_fa3);
rrv_fa3.setConstant(kFALSE);
TCanvas* c = new TCanvas("modelPlot","modelPlot",400,400);
rdh_KD_ps.plotOn(kdframe1,LineColor(kBlack));
pdf_KD_ps.plotOn(kdframe1,LineColor(kBlack));
rdh_KD_sm.plotOn(kdframe1,LineColor(kBlue));
pdf_KD_sm.plotOn(kdframe1,LineColor(kBlue));
model.plotOn(kdframe1,LineColor(kRed));
kdframe1->Draw();
c->SaveAs("model1DPlot.png");
c->SaveAs("model1DPlot.eps");
double fa3Val=-99;
if (mySample == kScalar_fa3_0)
fa3Val=0.;
else if (mySample == kScalar_fa3_1)
fa3Val=1;
else{
cout<<"fa3Val not correct!"<<endl;
return 0;
}
TCanvas* c = new TCanvas("modelPlot","modelPlot",400,400);
rdh_KD_ps.plotOn(kdframe1,LineColor(kBlack));
pdf_KD_ps.plotOn(kdframe1,LineColor(kBlack));
rdh_KD_sm.plotOn(kdframe1,LineColor(kBlue));
pdf_KD_sm.plotOn(kdframe1,LineColor(kBlue));
model.plotOn(kdframe1,LineColor(kRed));
kdframe1->Draw();
TChain* myChain = new TChain("newTree");
myChain->Add(inputFileNames[mySample]);
if(!myChain || myChain->GetEntries()<=0) {
cout<<"error in the tree"<<endl;
return 0;
}
RooDataSet* data = new RooDataSet("data","data",myChain,RooArgSet(*kd),"");
cout << "Number of events in data: " << data->numEntries() << endl;
// initialize tree to save toys to
TTree* results = new TTree("results","toy results");
double fa3,fa3Error, fa3Pull;
double fa2,fa2Error, fa2Pull;
double phia2, phia2Error, phia2Pull;
double phia3, phia3Error, phia3Pull;
results->Branch("fa3",&fa3,"fa3/D");
results->Branch("fa3Error",&fa3Error,"fa3Error/D");
results->Branch("fa3Pull",&fa3Pull,"fa3Pull/D");
//---------------------------------
RooDataSet* toyData;
int embedTracker=0;
RooArgSet *tempEvent;
RooFitResult *toyfitresults;
RooRealVar *r_fa3;
for(int i = 0 ; i<nToys ; i++){
cout <<i<<"<-----------------------------"<<endl;
//if(toyData) delete toyData;
toyData = new RooDataSet("toyData","toyData",RooArgSet(*kd));
if(nEvts+embedTracker > data->sumEntries()){
cout << "Playground::generate() - ERROR!!! Playground::data does not have enough events to fill toy!!!! bye :) " << endl;
toyData = NULL;
abort();
return 0;
}
for(int iEvent=0; iEvent<nEvts; iEvent++){
if(iEvent==1)
cout << "generating event: " << iEvent << " embedTracker: " << embedTracker << endl;
tempEvent = (RooArgSet*) data->get(embedTracker);
toyData->add(*tempEvent);
embedTracker++;
}
toyfitresults =model.fitTo(*toyData,Save());
cout<<toyfitresults<<endl;
r_fa3 = (RooRealVar *) toyfitresults->floatParsFinal().find("fa3");
fa3 = r_fa3->getVal();
fa3Error = r_fa3->getError();
fa3Pull = (r_fa3->getVal() - fa3Val) / r_fa3->getError();
// fill TTree
results->Fill();
//model.clear();
}
char nEvtsString[100];
sprintf(nEvtsString,"_%iEvts",nEvts);
// write tree to output file (ouputFileName set at top)
TFile *outputFile = new TFile("embeddedToysVBF_fa3Corr_"+sampleName[mySample]+nEvtsString+".root","RECREATE");
results->Write();
outputFile->Close();
}
void plotResolution() {
TStyle *mystyle = RooHZZStyle("ZZ");
mystyle->cd();
double binedgesZ[5] = {20,30,40,50,70};
double binedgesJPsi[4] = {7,10,20,40};
TGraphAsymmErrors gScaleZ[2][2];
TGraphAsymmErrors gResoZ[2][2];
TGraphAsymmErrors gScaleJPsi[2];
TGraphAsymmErrors gResoJPsi[2];
// Z->ee
for(int ipt=0; ipt<4; ++ipt) {
for(int ieta=0; ieta<2; ++ieta) {
for(int ir9=0; ir9<2; ++ir9) {
cout << "Analyzing pt bin = " << ipt << ", eta bin: " << ieta << " and r9 bin: " << ir9 << endl;
stringstream mcfile, datafile;
mcfile << "mcZ2012_PtBin" << ipt << "_EtaBin" << ieta << "_R9Bin" << ir9 << ".root";
datafile << "dataZ2012_PtBin" << ipt << "_EtaBin" << ieta << "_R9Bin" << ir9 << ".root";
TFile *tmcfile = TFile::Open(mcfile.str().c_str());
RooFitResult *mcfr = (RooFitResult*)tmcfile->Get("fitres");
float mcDM = ((RooRealVar*)(mcfr->floatParsFinal().find("#Deltam_{CB}")))->getVal();
float mcDM_err = ((RooRealVar*)(mcfr->floatParsFinal().find("#Deltam_{CB}")))->getError();
float mcS = ((RooRealVar*)(mcfr->floatParsFinal().find("#sigma_{CB}")))->getVal();
float mcS_err = ((RooRealVar*)(mcfr->floatParsFinal().find("#sigma_{CB}")))->getError();
mcS_err = effRmsFromSigmaCB(mcDM,mcDM_err,mcS,mcS_err);
TFile *tdatafile = TFile::Open(datafile.str().c_str());
RooFitResult *datafr = (RooFitResult*)tdatafile->Get("fitres");
float dataDM = ((RooRealVar*)(datafr->floatParsFinal().find("#Deltam_{CB}")))->getVal();
float dataDM_err = ((RooRealVar*)(datafr->floatParsFinal().find("#Deltam_{CB}")))->getError();
float dataS = ((RooRealVar*)(datafr->floatParsFinal().find("#sigma_{CB}")))->getVal();
float dataS_err = ((RooRealVar*)(datafr->floatParsFinal().find("#sigma_{CB}")))->getError();
dataS_err = effRmsFromSigmaCB(dataDM,dataDM_err,dataS,dataS_err);
float rM = (dataDM-mcDM)/(dataDM + 91.19);
float rM_err = rM * sqrt(dataDM_err*dataDM_err + mcDM_err*mcDM_err);
float delta = dataS-mcS;
float delta_err = sqrt(dataS_err*dataS_err+mcS_err*mcS_err);
float rS = delta/(mcS);
cout << "rS = " << rS << endl;
float rS_err = fabs(rS) * sqrt(pow(delta_err/delta,2) + pow(mcS_err/mcS,2));
float bincenter=(binedgesZ[ipt+1]+binedgesZ[ipt])/2.;
// add some offset not to overlap points
bincenter += (ieta==0) ? 2. : -2.;
bincenter += (ir9==0) ? 1. : -1.;
float binerrup=binedgesZ[ipt+1]-bincenter;
float binerrdn=bincenter-binedgesZ[ipt];
gScaleZ[ieta][ir9].SetPoint(ipt,bincenter,rM);
gScaleZ[ieta][ir9].SetPointError(ipt,binerrdn,binerrup,rM_err,rM_err);
gResoZ[ieta][ir9].SetPoint(ipt,bincenter,rS);
gResoZ[ieta][ir9].SetPointError(ipt,binerrdn,binerrup,rS_err,rS_err);
}
}
}
// JPsi->ee
for(int ipt=0; ipt<3; ++ipt) {
for(int ieta=0; ieta<1; ++ieta) {
cout << "Analyzing pt bin = " << ipt << ", eta bin: " << ieta << endl;
stringstream mcfile, datafile;
mcfile << "mcJPsi2012_PtBin" << ipt << "_EtaBin" << ieta << ".root";
datafile << "dataJPsi2012_PtBin" << ipt << "_EtaBin" << ieta << ".root";
TFile *tmcfile = TFile::Open(mcfile.str().c_str());
RooFitResult *mcfr = (RooFitResult*)tmcfile->Get("fitres");
float mcDM = ((RooRealVar*)(mcfr->floatParsFinal().find("#Deltam_{CB}")))->getVal();
float mcDM_err = ((RooRealVar*)(mcfr->floatParsFinal().find("#Deltam_{CB}")))->getError();
float mcS = ((RooRealVar*)(mcfr->floatParsFinal().find("#sigma_{CB}")))->getVal();
float mcS_err = ((RooRealVar*)(mcfr->floatParsFinal().find("#sigma_{CB}")))->getError();
TFile *tdatafile = TFile::Open(datafile.str().c_str());
RooFitResult *datafr = (RooFitResult*)tdatafile->Get("fitres");
float dataDM = ((RooRealVar*)(datafr->floatParsFinal().find("#Deltam_{CB}")))->getVal();
float dataDM_err = ((RooRealVar*)(datafr->floatParsFinal().find("#Deltam_{CB}")))->getError();
float dataS = ((RooRealVar*)(datafr->floatParsFinal().find("#sigma_{CB}")))->getVal();
float dataS_err = ((RooRealVar*)(datafr->floatParsFinal().find("#sigma_{CB}")))->getError();
float rM = (dataDM-mcDM)/(dataDM + 3.096);
float rM_err = rM * sqrt(dataDM_err*dataDM_err + mcDM_err*mcDM_err);
float delta = dataS-mcS;
float delta_err = sqrt(dataS_err*dataS_err+mcS_err*mcS_err);
float rS = delta/(mcS);
cout << "rS = " << rS << endl;
float rS_err = fabs(rS) * sqrt(pow(delta_err/delta,2) + pow(mcS_err/mcS,2));
float bincenter=(binedgesJPsi[ipt+1]+binedgesJPsi[ipt])/2.;
// add some offset not to overlap points
bincenter += (ieta==0) ? 0.5 : -0.5;
std::cout << "bincenter = " << bincenter << std::endl;
float binerrup=binedgesJPsi[ipt+1]-bincenter;
float binerrdn=bincenter-binedgesJPsi[ipt];
gScaleJPsi[ieta].SetPoint(ipt,bincenter,rM);
gScaleJPsi[ieta].SetPointError(ipt,binerrdn,binerrup,rM_err,rM_err);
gResoJPsi[ieta].SetPoint(ipt,bincenter,rS);
gResoJPsi[ieta].SetPointError(ipt,binerrdn,binerrup,rS_err,rS_err);
}
}
TCanvas *c1 = new TCanvas("c1","",600,600);
gScaleZ[0][0].GetXaxis()->SetTitle("electron p_{T} (GeV)");
gScaleZ[0][0].GetYaxis()->SetTitle("#Delta m/m (data - sim.)");
gScaleZ[0][0].Draw("AP");
for(int ieta=0; ieta<2; ++ieta) {
for(int ir9=0; ir9<2; ++ir9) {
if(ieta==0 && ir9==0) gScaleZ[0][0].Draw("AP");
else gScaleZ[ieta][ir9].Draw("P");
}
}
c1->SaveAs("delta-scale.pdf");
c1->SaveAs("delta-scale.png");
TCanvas *c2 = new TCanvas("c2","",600,600);
c2->SetLeftMargin(0.20);
c2->SetBottomMargin(0.20);
c2->SetTopMargin(0.10);
gResoZ[0][0].GetXaxis()->SetTitle("electron p_{T} (GeV)");
gResoZ[0][0].GetYaxis()->SetTitle("(#sigma^{data}_{eff}-#sigma^{MC}_{eff})/#sigma^{MC}_{eff}");
gResoZ[0][0].GetYaxis()->SetTitleOffset(1.8);
gResoZ[0][0].GetXaxis()->SetTitleOffset(1.5);
for(int ieta=0; ieta<2; ++ieta) {
for(int ir9=0; ir9<2; ++ir9) {
gResoZ[ieta][ir9].SetMarkerSize(1.);
gResoZ[ieta][ir9].GetYaxis()->SetRangeUser(-0.30,0.30);
gResoZ[ieta][ir9].GetXaxis()->SetLimits(0,80);
if(ieta==0) {
gResoZ[ieta][ir9].SetMarkerColor(kAzure-3);
gResoZ[ieta][ir9].SetLineColor(kAzure-3);
}
if(ieta==1) {
gResoZ[ieta][ir9].SetMarkerColor(kGreen-3);
gResoZ[ieta][ir9].SetLineColor(kGreen-3);
}
if(ir9==0) gResoZ[ieta][ir9].SetMarkerStyle(kFullCircle);
if(ir9==1) gResoZ[ieta][ir9].SetMarkerStyle(kOpenTriangleUp);
if(ieta==0 && ir9==0) gResoZ[0][0].Draw("AP");
else gResoZ[ieta][ir9].Draw("P");
}
}
gResoJPsi[0].SetMarkerColor(kRed-3);
gResoJPsi[0].SetLineColor(kRed-3);
gResoJPsi[0].SetMarkerSize(1.);
gResoJPsi[0].SetMarkerStyle(kOpenSquare);
gResoJPsi[0].GetYaxis()->SetRangeUser(-0.30,0.30);
gResoJPsi[0].GetXaxis()->SetLimits(0.,80);
gResoJPsi[0].Draw("P");
TLegend* leg = new TLegend(0.50,0.20,0.90,0.50);
leg->SetFillStyle(0); leg->SetBorderSize(0); leg->SetTextSize(0.03);
leg->SetTextFont(42);
leg->SetFillColor(0);
leg->AddEntry(&gResoZ[0][0],"Z, |#eta|<1.5, golden","pl");
leg->AddEntry(&gResoZ[0][1],"Z, |#eta|<1.5, showering","pl");
leg->AddEntry(&gResoZ[1][0],"Z, |#eta|>1.5, golden","pl");
leg->AddEntry(&gResoZ[1][1],"Z, |#eta|>1.5, showering","pl");
leg->AddEntry(&gResoJPsi[0],"J/#psi , |#eta|<1.5","pl");
leg->Draw();
TPaveText *pt = new TPaveText(-3,0.32,70,0.35,"br");
pt->SetBorderSize(0);
pt->SetFillStyle(0);
pt->SetTextAlign(12);
pt->SetTextFont(42);
pt->SetTextSize(0.04);
pt->AddText("CMS, #sqrt{s} = 8 TeV, #intL dt = 19.6 fb^{-1}");
pt->Draw();
TLine *zero = new TLine(0,0,80,0);
zero->SetLineColor(kGray+2);
zero->SetLineWidth(1);
zero->Draw();
c2->SaveAs("delta-resolution.pdf");
c2->SaveAs("delta-resolution.png");
c2->SaveAs("delta-resolution.C");
}
void Fit3D::plotFitAccuracy(
const RooDataSet& mc_data,
const RooFitResult& fit)
{
fit.Print("v");
double n_true_bs = mc_data.sumEntries("component == component::bs");
double n_true_bd = mc_data.sumEntries("component == component::bd");
double n_true_cw = mc_data.sumEntries("component == component::cw");
double n_true_ww = mc_data.sumEntries("component == component::ww");
double n_true_cn = mc_data.sumEntries("component == component::cn");
RooRealVar* bs_fit = (RooRealVar*) fit.floatParsFinal().find("n_bs_pp");
RooRealVar* bd_fit = (RooRealVar*) fit.floatParsFinal().find("n_bd_pp");
RooRealVar* cw_fit = (RooRealVar*) fit.floatParsFinal().find("n_cw_pp");
RooRealVar* ww_fit = (RooRealVar*) fit.floatParsFinal().find("n_ww_pp");
RooRealVar* cn_fit = (RooRealVar*) fit.floatParsFinal().find("n_cn_pp");
TString title("Fit Accuracy (N^{++}_{fit}-N^{++}_{true})");
TString filename(output_path_ + "fit_accuracy_pp");
if (!bs_fit) {
bs_fit = (RooRealVar*) fit.floatParsFinal().find("n_bs_nn");
bd_fit = (RooRealVar*) fit.floatParsFinal().find("n_bd_nn");
cw_fit = (RooRealVar*) fit.floatParsFinal().find("n_cw_nn");
ww_fit = (RooRealVar*) fit.floatParsFinal().find("n_ww_nn");
cn_fit = (RooRealVar*) fit.floatParsFinal().find("n_cn_nn");
title = TString("Fit Accuracy (N^{--}_{fit}-N^{--}_{true})");
filename = TString(output_path_ + "fit_accuracy_nn");
}
if (!bs_fit) {
// Error. Quit while ahead.
cout << "Error in plotFitAccuracy(): "
<< "Cannot find fit variables. Check names are valid."
<< endl;
return;
}
std::cout << n_true_bd << std::endl;
std::cout << n_true_bs << std::endl;
std::cout << n_true_cn << std::endl;
std::cout << n_true_cw << std::endl;
std::cout << n_true_ww << std::endl;
TCanvas c1("c1", title, 200, 10, 700, 500);
c1.SetGrid();
double x[5] = {1, 2, 3, 4, 5};
double y[5] = {
bs_fit->getVal() - n_true_bs,
bd_fit->getVal() - n_true_bd,
cw_fit->getVal() - n_true_cw,
ww_fit->getVal() - n_true_ww,
cn_fit->getVal() - n_true_cn};
double exl[5] = {0, 0, 0, 0, 0};
double exh[5] = {0, 0, 0, 0, 0};
double eyl[5] = {
-bs_fit->getErrorLo(),
-bd_fit->getErrorLo(),
-cw_fit->getErrorLo(),
-ww_fit->getErrorLo(),
-cn_fit->getErrorLo()};
double eyh[5] = {
bs_fit->getErrorHi(),
bd_fit->getErrorHi(),
cw_fit->getErrorHi(),
ww_fit->getErrorHi(),
cn_fit->getErrorHi()};
TGraphAsymmErrors* gr = new TGraphAsymmErrors(5, x, y, exl, exh, eyl, eyh);
TLatex* cc_bs_label = new TLatex(gr->GetX()[0], gr->GetY()[0], " CC (B_{s})");
TLatex* cc_bd_label = new TLatex(gr->GetX()[1], gr->GetY()[1], " CC (B_{d})");
TLatex* cw_label = new TLatex(gr->GetX()[2], gr->GetY()[2], " CW");
TLatex* ww_label = new TLatex(gr->GetX()[3], gr->GetY()[3], " WW");
TLatex* cn_label = new TLatex(gr->GetX()[4], gr->GetY()[4], " CN");
gr->GetListOfFunctions()->Add(cc_bs_label);
gr->GetListOfFunctions()->Add(cc_bd_label);
gr->GetListOfFunctions()->Add(cw_label);
gr->GetListOfFunctions()->Add(ww_label);
gr->GetListOfFunctions()->Add(cn_label);
gr->SetTitle(title);
gr->SetMarkerStyle(kOpenCircle);
gr->SetMarkerColor(4);
gr->Draw("AP");
c1.Print(filename + ".eps");
TFile accuracy_plot_file(filename + ".root", "RECREATE");
gr->Write();
accuracy_plot_file.Close();
return;
}
void estimateSignalFitPerformance()
{
//open the ROOT efficiency file
TFile ROOTFile(efficiencyFile.c_str());
if (!ROOTFile.IsOpen()) {
cerr << "Error opening file " << efficiencyFile << ".\n";
return;
}
//get numBackgroundFail, numBackgroundPass, numSignalAll, and efficiency
RooFitResult* fitResult = NULL;
ROOTFile.GetObject("PhotonToIDEB/unbinned/probe_eta_bin0__probe_nJets05_bin0__gaussPlusLinear/fitresults", fitResult);
Double_t efficiency = 0.0;
Double_t efficiencyError = 0.0;
Double_t numBackgroundFail = 0.0;
Double_t numBackgroundFailError = 0.0;
Double_t numBackgroundPass = 0.0;
Double_t numBackgroundPassError = 0.0;
Double_t numSignalAll = 0.0;
Double_t numSignalAllError = 0.0;
if (fitResult != NULL) {
RooRealVar* theEfficiency = (RooRealVar*)fitResult->floatParsFinal().find("efficiency");
efficiency = theEfficiency->getVal();
efficiencyError = theEfficiency->getError();
RooRealVar* theNumBackgroundFail = (RooRealVar*)fitResult->floatParsFinal().find("numBackgroundFail");
numBackgroundFail = theNumBackgroundFail->getVal();
numBackgroundFailError = theNumBackgroundFail->getError();
RooRealVar* theNumBackgroundPass = (RooRealVar*)fitResult->floatParsFinal().find("numBackgroundPass");
numBackgroundPass = theNumBackgroundPass->getVal();
numBackgroundPassError = theNumBackgroundPass->getError();
RooRealVar* theNumSignalAll = (RooRealVar*)fitResult->floatParsFinal().find("numSignalAll");
numSignalAll = theNumSignalAll->getVal();
numSignalAllError = theNumSignalAll->getError();
}
else {
cerr << "Error getting RooFitResult PhotonToIDEB/unbinned/probe_eta_bin0__probe_nJets05_bin0__gaussPlusLinear/fitresults from file ";
cerr << efficiencyFile << ".\n";
}
//get integrals of tag-pass and tag-fail distributions
TCanvas* fitCanvas = NULL;
ROOTFile.GetObject("PhotonToIDEB/unbinned/probe_eta_bin0__probe_nJets05_bin0__gaussPlusLinear/fit_canvas", fitCanvas);
Double_t tagPassIntegral = 0;
Double_t tagFailIntegral = 0;
if (fitCanvas != NULL) {
fitCanvas->cd(1);
RooHist* tagPassDistribution = NULL;
tagPassDistribution = (RooHist*)((TCanvas*)fitCanvas->GetPrimitive("fit_canvas_1"))->GetPrimitive("h_data");
fitCanvas->cd(2);
RooHist* tagFailDistribution = NULL;
tagFailDistribution = (RooHist*)((TCanvas*)fitCanvas->GetPrimitive("fit_canvas_2"))->GetPrimitive("h_data");
RooHist* blah = NULL;
blah = (RooHist*)((TCanvas*)fitCanvas->GetPrimitive("fit_canvas_3"))->GetPrimitive("h_data");
cerr << blah->Integral() << endl;
if ((tagPassDistribution != NULL) && (tagFailDistribution != NULL)) {
tagPassIntegral = tagPassDistribution->Integral()*/*1.796*/1.844;
tagFailIntegral = tagFailDistribution->Integral()*/*1.796*/1.844;
}
else cerr << "Error: could not get RooPlots.\n";
}
else {
cerr << "Error getting TCanvas PhotonToIDEB/unbinned/probe_eta_bin0__probe_nJets05_bin0__gaussPlusLinear/fit_canvas from file ";
cerr << efficiencyFile << ".\n";
}
//close file
ROOTFile.Close();
//subtract fitted background from integral
Double_t tagPassNumBkgSubtractedEvts = tagPassIntegral - numBackgroundPass;
Double_t tagPassNumBkgSubtractedEvtsError = numBackgroundPassError;
Double_t tagFailNumBkgSubtractedEvts = tagFailIntegral - numBackgroundFail;
Double_t tagFailNumBkgSubtractedEvtsError = numBackgroundFailError;
//calculate fitted signal
Double_t tagPassNumFittedSignal = efficiency*numSignalAll;
Double_t tagPassNumFittedSignalError = tagPassNumFittedSignal*sqrt(((efficiencyError*efficiencyError)/(efficiency*efficiency)) +
((numSignalAllError*numSignalAllError)/(numSignalAll*numSignalAll)));
Double_t tagFailNumFittedSignal = (1.0 - efficiency)*numSignalAll;
Double_t tagFailNumFittedSignalError = tagFailNumFittedSignal*
sqrt(((efficiencyError*efficiencyError)/((1.0 - efficiency)*(1.0 - efficiency))) +
((numSignalAllError*numSignalAllError)/(numSignalAll*numSignalAll)));
//calculate difference between signal fit result and background subtracted integral
Double_t tagPassDifference = tagPassNumBkgSubtractedEvts - tagPassNumFittedSignal;
Double_t tagPassDifferenceError = sqrt(tagPassNumBkgSubtractedEvtsError*tagPassNumBkgSubtractedEvtsError +
tagPassNumFittedSignalError*tagPassNumFittedSignalError);
Double_t tagFailDifference = tagFailNumBkgSubtractedEvts - tagFailNumFittedSignal;
Double_t tagFailDifferenceError = sqrt(tagFailNumBkgSubtractedEvtsError*tagFailNumBkgSubtractedEvtsError +
tagFailNumFittedSignalError*tagFailNumFittedSignalError);
//compare signal fit result to background subtracted integral
cout << "Tag pass signal fit: " << tagPassNumFittedSignal << " +/- " << tagPassNumFittedSignalError << endl;
cout << "Tag pass background subtracted integral: " << tagPassNumBkgSubtractedEvts << " +/- " << tagPassNumBkgSubtractedEvtsError;
cout << endl;
cout << "Difference: " << tagPassDifference << " +/- " << tagPassDifferenceError << endl;
cout << "Tag fail signal fit: " << tagFailNumFittedSignal << " +/- " << tagFailNumFittedSignalError << endl;
cout << "Tag fail background subtracted integral: " << tagFailNumBkgSubtractedEvts << " +/- " << tagFailNumBkgSubtractedEvtsError;
cout << endl;
cout << "Difference: " << tagFailDifference << " +/- " << tagFailDifferenceError << endl;
}
void embeddedToysWithBackgDetEffects_1DKD(int nEvts=600, int nToys=3000,
sample mySample = kScalar_fa3p5,
bool bkg, bool sigFloating, int counter){
RooRealVar* kd = new RooRealVar("psMELA","psMELA",0,1);
kd->setBins(1000);
RooPlot* kdframe1 = kd->frame();
// 0- template
TFile f1("KDdistribution_ps_analytical_detEff.root", "READ");
TH1F *h_KD_ps = (TH1F*)f1.Get("h_KD");
h_KD_ps->SetName("h_KD_ps");
RooDataHist rdh_KD_ps("rdh_KD_ps","rdh_KD_ps",RooArgList(*kd),h_KD_ps);
RooHistPdf pdf_KD_ps("pdf_KD_ps","pdf_KD_ps",RooArgList(*kd),rdh_KD_ps);
// 0+ template
TFile f2("KDdistribution_sm_analytical_detEff.root", "READ");
TH1F *h_KD_sm = (TH1F*)f2.Get("h_KD");
h_KD_sm->SetName("h_KD_sm");
RooDataHist rdh_KD_sm("rdh_KD_sm","rdh_KD_sm",RooArgList(*kd),h_KD_sm);
RooHistPdf pdf_KD_sm("pdf_KD_sm","pdf_KD_sm",RooArgList(*kd),rdh_KD_sm);
// backg template
TFile f3("KDdistribution_bkg_analytical_detEff.root", "READ");
TH1F *h_KD_bkg = (TH1F*)f3.Get("h_KD");
h_KD_bkg->SetName("h_KD_bkg");
RooDataHist rdh_KD_bkg("rdh_KD_bkg","rdh_KD_bkg",RooArgList(*kd),h_KD_bkg);
RooHistPdf pdf_KD_bkg("pdf_KD_bkg","pdf_KD_bkg",RooArgList(*kd),rdh_KD_bkg);
//Define signal model with 0+, 0- mixture
RooRealVar rrv_fa3("fa3","fa3",0.5,0.,1.); //free parameter of the model
RooFormulaVar rfv_fa3Obs("fa3obs","1/ (1 + (1/@0 - 1)*0.99433)",RooArgList(rrv_fa3));
RooAddPdf modelSignal("modelSignal","ps+sm",pdf_KD_ps,pdf_KD_sm,rfv_fa3Obs);
rrv_fa3.setConstant(kFALSE);
//Define signal+bakground model
RooRealVar rrv_BoverTOT("BoverTOT","BoverTOT",1/(3.75+1),0.,10.);
RooAddPdf model("model","background+modelSignal",pdf_KD_bkg,modelSignal,rrv_BoverTOT);
if(sigFloating)
rrv_BoverTOT.setConstant(kFALSE);
else
rrv_BoverTOT.setConstant(kTRUE);
//Set the values of free parameters to compute pulls
double fa3Val=-99;
if (mySample == kScalar_fa3p0)
fa3Val=0.;
else if (mySample == kScalar_fa3p1)
fa3Val=0.1;
else if (mySample == kScalar_fa3p5 || mySample == kScalar_fa3p5phia390)
fa3Val=0.5;
else if (mySample == kScalar_fa3p25)
fa3Val=0.25;
else{
cout<<"fa3Val not correct!"<<endl;
return 0;
}
double sigFracVal=1 - 1/(3.75+1);
//Plot the models
TCanvas* c = new TCanvas("modelPlot_detBkg","modelPlot_detBkg",400,400);
rdh_KD_ps.plotOn(kdframe1,LineColor(kBlack),MarkerColor(kBlack));
pdf_KD_ps.plotOn(kdframe1,LineColor(kBlack),RooFit::Name("pseudo"));
//rdh_KD_sm.plotOn(kdframe1,LineColor(kBlue),MarkColor(kBlue));
pdf_KD_sm.plotOn(kdframe1,LineColor(kBlue),RooFit::Name("SM"));
//rdh_KD_bkg.plotOn(kdframe1,LineColor(kGreen),LineColor(kGreen));
pdf_KD_bkg.plotOn(kdframe1,LineColor(kGreen),RooFit::Name("bkg"));
modelSignal.plotOn(kdframe1,LineColor(kRed),RooFit::Name("signal_fa3p5"));
model.plotOn(kdframe1,LineColor(kOrange),RooFit::Name("signal+background"));
TLegend *leg = new TLegend (0.7,0.6,0.95,0.8);
leg->AddEntry(kdframe1->findObject("pseudo"),"0-","L");
leg->AddEntry(kdframe1->findObject("SM"),"0+","L");
leg->AddEntry(kdframe1->findObject("bkg"),"bkg","L");
leg->AddEntry(kdframe1->findObject("signal_fa3p5"),"signal fa3=0.5","L");
leg->AddEntry(kdframe1->findObject("signal+background"),"signal + bkg","L");
kdframe1->Draw();
leg->SetFillColor(kWhite);
leg->Draw("same");
c->SaveAs("modelPlot_detBkg.eps");
c->SaveAs("modelPlot_detBkg.png");
//Load the trees into the datasets
TChain* myChain = new TChain("SelectedTree");
myChain->Add(inputFileNames[mySample]);
if(!myChain || myChain->GetEntries()<=0) {
cout<<"error in the tree"<<endl;
return 0;
}
RooDataSet* data = new RooDataSet("data","data",myChain,RooArgSet(*kd),"");
TChain* myChain_bkg = new TChain("SelectedTree");
myChain_bkg->Add("samples/analyticalpsMELA/withResolution/pwgevents_mllCut10_smeared_withDiscriminants_2e2mu_cutDetector.root");
myChain_bkg->Add("samples/analyticalpsMELA/withResolution/pwgevents_mllCut4_wResolution_withDiscriminants_cutDetector.root");
if(!myChain_bkg || myChain_bkg->GetEntries()<=0) {
cout<<"error in the tree"<<endl;
return 0;
}
RooDataSet* data_bkg = new RooDataSet("data_bkg","data_bkg",myChain_bkg,RooArgSet(*kd),"");
cout << "Number of events in data sig: " << data->numEntries() << endl;
cout << "Number of events in data bkg: " << data_bkg->numEntries() << endl;
// Initialize tree to save toys to
TTree* results = new TTree("results","toy results");
double fa3,fa3Error, fa3Pull;
double sigFrac,sigFracError, sigFracPull;
double significance;
results->Branch("fa3",&fa3,"fa3/D");
results->Branch("fa3Error",&fa3Error,"fa3Error/D");
results->Branch("fa3Pull",&fa3Pull,"fa3Pull/D");
results->Branch("sigFrac",&sigFrac,"sigFrac/D");
results->Branch("sigFracError",&sigFracError,"sigFracError/D");
results->Branch("sigFracPull",&sigFracPull,"sigFracPull/D");
results->Branch("significance",&significance,"significance/D");
//---------------------------------
RooDataSet* toyData;
RooDataSet* toyData_bkgOnly;
int embedTracker=nEvts*counter;
int embedTracker_bkg=TMath::Ceil(nEvts/3.75*counter);
RooArgSet *tempEvent;
RooFitResult *toyfitresults;
RooFitResult *toyfitresults_sigBkg;
RooFitResult *toyfitresults_bkgOnly;
RooRealVar *r_fa3;
RooRealVar *r_sigFrac;
for(int i = 0 ; i<nToys ; i++){
cout <<i<<"<-----------------------------"<<endl;
//if(toyData) delete toyData;
toyData = new RooDataSet("toyData","toyData",RooArgSet(*kd));
toyData_bkgOnly = new RooDataSet("toyData_bkgOnly","toyData_bkgOnly",RooArgSet(*kd));
if(nEvts+embedTracker > data->sumEntries()){
cout << "Playground::generate() - ERROR!!! Playground::data does not have enough events to fill toy!!!! bye :) " << endl;
toyData = NULL;
abort();
return 0;
}
if(nEvts+embedTracker_bkg > data_bkg->sumEntries()){
cout << "Playground::generate() - ERROR!!! Playground::data does not have enough events to fill toy!!!! bye :) " << endl;
toyData = NULL;
abort();
return 0;
}
for(int iEvent=0; iEvent<nEvts; iEvent++){
if(iEvent==1)
cout << "generating event: " << iEvent << " embedTracker: " << embedTracker << endl;
tempEvent = (RooArgSet*) data->get(embedTracker);
toyData->add(*tempEvent);
embedTracker++;
}
if(bkg){
for(int iEvent=0; iEvent<nEvts/3.75; iEvent++){
if(iEvent==1)
cout << "generating bkg event: " << iEvent << " embedTracker bkg: " << embedTracker_bkg << endl;
tempEvent = (RooArgSet*) data_bkg->get(embedTracker_bkg);
toyData->add(*tempEvent);
toyData_bkgOnly->add(*tempEvent);
embedTracker_bkg++;
}
}
if(bkg)
toyfitresults =model.fitTo(*toyData,Save());
else
toyfitresults =modelSignal.fitTo(*toyData,Save());
//cout<<toyfitresults<<endl;
r_fa3 = (RooRealVar *) toyfitresults->floatParsFinal().find("fa3");
fa3 = r_fa3->getVal();
fa3Error = r_fa3->getError();
fa3Pull = (r_fa3->getVal() - fa3Val) / r_fa3->getError();
if(sigFloating){
r_sigFrac = (RooRealVar *) toyfitresults->floatParsFinal().find("BoverTOT");
sigFrac = 1-r_sigFrac->getVal();
sigFracError = r_sigFrac->getError();
sigFracPull = (1-r_sigFrac->getVal() - sigFracVal) / r_sigFrac->getError();
}
// fill TTree
results->Fill();
}
char nEvtsString[100];
sprintf(nEvtsString,"_%iEvts_%iiter",nEvts, counter);
// write tree to output file (ouputFileName set at top)
TFile *outputFile = new TFile("embeddedToys1DKD_fa3Corr_WithBackgDetEffects_"+sampleName[mySample]+nEvtsString+".root","RECREATE");
results->Write();
outputFile->Close();
}
prepDataFiles(){
// TDirectory *theDr = (TDirectory*) myFile->Get("eleIDdir");///denom_pt/fit_eff_plots");
//theDr->ls();
int myIndex;
TSystemDirectory dir(thePath, thePath);
TSystemFile *file;
TString fname;
TIter next(dir.GetListOfFiles());
while ((file=(TSystemFile*)next())) {
fname = file->GetName();
if (fname.BeginsWith("TnP")&& fname.Contains("mc")) {
ofstream myfile;
TFile *myFile = new TFile(fname);
TIter nextkey(myFile->GetListOfKeys());
TKey *key;
while (key = (TKey*)nextkey()) {
TString theTypeClasse = key->GetClassName();
TString theNomClasse = key->GetTitle();
if ( theTypeClasse == "TDirectoryFile"){
TDirectory *theDr = (TDirectory*) myFile->Get(theNomClasse);
TIter nextkey2(theDr->GetListOfKeys());
TKey *key2;
while (key2 = (TKey*)nextkey2()) {
TString theTypeClasse2 = key2->GetClassName();
TString theNomClasse2 = key2->GetTitle();
myfile.open (theNomClasse2+".info");
if ( theTypeClasse == "TDirectoryFile"){
cout << "avant " << endl;
TDirectory *theDr2 = (TDirectory*) myFile->Get(theNomClasse+"/"+theNomClasse2);
cout << "apres " << endl;
TIter nextkey3(theDr2->GetListOfKeys());
TKey *key3;
while (key3 = (TKey*)nextkey3()) {
TString theTypeClasse3 = key3->GetClassName();
TString theNomClasse3 = key3->GetTitle();
if ((theNomClasse3.Contains("FromMC"))) {
TString localClasse3 = theNomClasse3;
localClasse3.ReplaceAll("__","%");
cout << "apres " << localClasse3 << endl;
TObjArray* listBin = localClasse3.Tokenize('%');
TString first = ((TObjString*)listBin->At(0))->GetString();
TString second = ((TObjString*)listBin->At(2))->GetString();
myfile << first;
myfile << " " << second << " ";
cout << "coucou la on va récupérer le rooFitResult " << endl;
RooFitResult *theResults = (RooFitResult*) myFile->Get(theNomClasse+"/"+theNomClasse2+"/"+theNomClasse3+"/fitresults");
theResults->Print();
RooArgList theParam = theResults->floatParsFinal();
int taille = theParam.getSize();
for (int m = 0 ; m < taille ; m++){
cout << "m=" << m << endl;
RooAbsArg *theArg = (RooAbsArg*) theParam.at(m);
RooAbsReal *theReal = (RooAbsReal*) theArg;
myfile << theReal->getVal() << " " ;
}
myfile << "\n";
}
}
}
myfile.close();
}
}
}
delete myFile;
}
}
}
vector<Double_t*> simFit(bool makeSoupFit_ = false,
const string tnp_ = "etoTauMargLooseNoCracks70",
const string category_ = "tauAntiEMVA",
const string bin_ = "abseta<1.5",
const float binCenter_ = 0.75,
const float binWidth_ = 0.75,
const float xLow_=60,
const float xHigh_=120,
bool SumW2_ = false,
bool verbose_ = true){
vector<Double_t*> out;
//return out;
//TFile *test = new TFile( outFile->GetName(),"UPDATE");
// output file
TFile *test = new TFile( Form("EtoTauPlotsFit_%s_%s_%f.root",tnp_.c_str(),category_.c_str(),binCenter_),"RECREATE");
test->mkdir(Form("bin%f",binCenter_));
TCanvas *c = new TCanvas("fitCanvas",Form("fitCanvas_%s_%s",tnp_.c_str(),bin_.c_str()),10,30,650,600);
c->SetGrid(0,0);
c->SetFillStyle(4000);
c->SetFillColor(10);
c->SetTicky();
c->SetObjectStat(0);
TCanvas *c2 = new TCanvas("fitCanvasTemplate",Form("fitCanvasTemplate_%s_%s",tnp_.c_str(),bin_.c_str()),10,30,650,600);
c2->SetGrid(0,0);
c2->SetFillStyle(4000);
c2->SetFillColor(10);
c2->SetTicky();
c2->SetObjectStat(0);
// input files
TFile fsup("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_soup.root");
TFile fbkg("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_soup_bkg.root");
TFile fsgn("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_soup_sgn.root");
TFile fdat("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_Data.root");
// data from 2iter:
//TFile fdat("/data_CMS/cms/lbianchini/35pb/testNewWriteFromPAT_Data.root");
//********************** signal only tree *************************/
TTree *fullTreeSgn = (TTree*)fsgn.Get((tnp_+"/fitter_tree").c_str());
TH1F* hSall = new TH1F("hSall","",1,0,150);
TH1F* hSPall = new TH1F("hSPall","",1,0,150);
TH1F* hS = new TH1F("hS","",1,0,150);
TH1F* hSP = new TH1F("hSP","",1,0,150);
fullTreeSgn->Draw("mass>>hS",Form("weight*(%s && mass>%f && mass<%f && mcTrue && signalPFChargedHadrCands<1.5)",bin_.c_str(),xLow_,xHigh_));
fullTreeSgn->Draw("mass>>hSall",Form("weight*(%s && mass>%f && mass<%f)",bin_.c_str(),xLow_,xHigh_));
float SGNtrue = hS->Integral();
float SGNall = hSall->Integral();
fullTreeSgn->Draw("mass>>hSP",Form("weight*(%s && %s>0 && mass>%f && mass<%f && mcTrue && signalPFChargedHadrCands<1.5 )",bin_.c_str(),category_.c_str(),xLow_,xHigh_));
fullTreeSgn->Draw("mass>>hSPall",Form("weight*(%s && %s>0 && mass>%f && mass<%f && signalPFChargedHadrCands<1.5 )",bin_.c_str(),category_.c_str(),xLow_,xHigh_));
float SGNtruePass = hSP->Integral();
float SGNallPass = hSPall->Integral();
//********************** background only tree *************************//
TTree *fullTreeBkg = (TTree*)fbkg.Get((tnp_+"/fitter_tree").c_str());
TH1F* hB = new TH1F("hB","",1,0,150);
TH1F* hBP = new TH1F("hBP","",1,0,150);
fullTreeBkg->Draw("mass>>hB",Form("weight*(%s && mass>%f && mass<%f && signalPFChargedHadrCands<1.5 )",bin_.c_str(),xLow_,xHigh_));
float BKG = hB->Integral();
float BKGUnWeighted = hB->GetEntries();
fullTreeBkg->Draw("mass>>hBP",Form("weight*(%s && %s>0 && mass>%f && mass<%f && signalPFChargedHadrCands<1.5 )",bin_.c_str(),category_.c_str(),xLow_,xHigh_));
float BKGPass = hBP->Integral();
float BKGUnWeightedPass = hBP->GetEntries();
float BKGFail = BKG-BKGPass;
cout << "*********** BKGFail " << BKGFail << endl;
//********************** soup tree *************************//
TTree *fullTreeSoup = (TTree*)fsup.Get((tnp_+"/fitter_tree").c_str());
//********************** data tree *************************//
TTree *fullTreeData = (TTree*)fdat.Get((tnp_+"/fitter_tree").c_str());
//********************** workspace ***********************//
RooWorkspace *w = new RooWorkspace("w","w");
// tree variables to be imported
w->factory("mass[30,120]");
w->factory("weight[0,10000]");
w->factory("abseta[0,2.5]");
w->factory("pt[0,200]");
w->factory("mcTrue[0,1]");
w->factory("signalPFChargedHadrCands[0,10]");
w->factory((category_+"[0,1]").c_str());
// background pass pdf for MC
w->factory("RooExponential::McBackgroundPdfP(mass,McCP[0,-10,10])");
// background fail pdf for MC
w->factory("RooExponential::McBackgroundPdfF(mass,McCF[0,-10,10])");
// background pass pdf for Data
w->factory("RooExponential::DataBackgroundPdfP(mass,DataCP[0,-10,10])");
// background fail pdf for Data
w->factory("RooExponential::DataBackgroundPdfF(mass,DataCF[0,-10,10])");
// fit parameters for background
w->factory("McEfficiency[0.04,0,1]");
w->factory("McNumSgn[0,1000000]");
w->factory("McNumBkgP[0,100000]");
w->factory("McNumBkgF[0,100000]");
w->factory("expr::McNumSgnP('McEfficiency*McNumSgn',McEfficiency,McNumSgn)");
w->factory("expr::McNumSgnF('(1-McEfficiency)*McNumSgn',McEfficiency,McNumSgn)");
w->factory("McPassing[pass=1,fail=0]");
// fit parameters for data
w->factory("DataEfficiency[0.1,0,1]");
w->factory("DataNumSgn[0,1000000]");
w->factory("DataNumBkgP[0,1000000]");
w->factory("DataNumBkgF[0,10000]");
w->factory("expr::DataNumSgnP('DataEfficiency*DataNumSgn',DataEfficiency,DataNumSgn)");
w->factory("expr::DataNumSgnF('(1-DataEfficiency)*DataNumSgn',DataEfficiency,DataNumSgn)");
w->factory("DataPassing[pass=1,fail=0]");
RooRealVar *weight = w->var("weight");
RooRealVar *abseta = w->var("abseta");
RooRealVar *pt = w->var("pt");
RooRealVar *mass = w->var("mass");
mass->setRange(xLow_,xHigh_);
RooRealVar *mcTrue = w->var("mcTrue");
RooRealVar *cut = w->var( category_.c_str() );
RooRealVar *signalPFChargedHadrCands = w->var("signalPFChargedHadrCands");
// build the template for the signal pass sample:
RooDataSet templateP("templateP","dataset for signal-pass template", RooArgSet(*mass,*weight,*abseta,*pt,*cut,*mcTrue,*signalPFChargedHadrCands), Import( *fullTreeSgn ), /*WeightVar( *weight ),*/ Cut( Form("(mcTrue && %s>0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()) ) );
// build the template for the signal fail sample:
RooDataSet templateF("templateF","dataset for signal-fail template", RooArgSet(*mass,*weight,*abseta,*pt,*cut,*mcTrue,*signalPFChargedHadrCands), Import( *fullTreeSgn ), /*WeightVar( *weight ),*/ Cut( Form("(mcTrue && %s<0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()) ) );
mass->setBins(24);
RooDataHist templateHistP("templateHistP","",RooArgSet(*mass), templateP, 1.0);
RooHistPdf TemplateSignalPdfP("TemplateSignalPdfP","",RooArgSet(*mass),templateHistP);
w->import(TemplateSignalPdfP);
mass->setBins(24);
RooDataHist templateHistF("templateHistF","",RooArgSet(*mass),templateF,1.0);
RooHistPdf TemplateSignalPdfF("TemplateSignalPdfF","",RooArgSet(*mass),templateHistF);
w->import(TemplateSignalPdfF);
mass->setBins(10000,"fft");
RooPlot* TemplateFrameP = mass->frame(Bins(24),Title("Template passing"));
templateP.plotOn(TemplateFrameP);
w->pdf("TemplateSignalPdfP")->plotOn(TemplateFrameP);
RooPlot* TemplateFrameF = mass->frame(Bins(24),Title("Template failing"));
templateF.plotOn(TemplateFrameF);
w->pdf("TemplateSignalPdfF")->plotOn(TemplateFrameF);
//w->factory("RooFFTConvPdf::McSignalPdfP(mass,TemplateSignalPdfP,RooTruthModel::McResolModP(mass))");
//w->factory("RooFFTConvPdf::McSignalPdfF(mass,TemplateSignalPdfF,RooTruthModel::McResolModF(mass))");
// FOR GREGORY: PROBLEM WHEN TRY TO USE THE PURE TEMPLATE =>
RooHistPdf McSignalPdfP("McSignalPdfP","McSignalPdfP",RooArgSet(*mass),templateHistP);
RooHistPdf McSignalPdfF("McSignalPdfF","McSignalPdfF",RooArgSet(*mass),templateHistF);
w->import(McSignalPdfP);
w->import(McSignalPdfF);
// FOR GREGORY: FOR DATA, CONVOLUTION IS OK =>
w->factory("RooFFTConvPdf::DataSignalPdfP(mass,TemplateSignalPdfP,RooGaussian::DataResolModP(mass,DataMeanResP[0.0,-5.,5.],DataSigmaResP[0.5,0.,10]))");
w->factory("RooFFTConvPdf::DataSignalPdfF(mass,TemplateSignalPdfF,RooGaussian::DataResolModF(mass,DataMeanResF[-5.,-10.,10.],DataSigmaResF[0.5,0.,10]))");
//w->factory("RooCBShape::DataSignalPdfF(mass,DataMeanF[91.2,88,95.],DataSigmaF[3,0.5,8],DataAlfaF[1.8,0.,10],DataNF[1.0,1e-06,10])");
//w->factory("RooFFTConvPdf::DataSignalPdfF(mass,RooVoigtian::DataVoigF(mass,DataMeanF[85,80,95],DataWidthF[2.49],DataSigmaF[3,0.5,10]),RooCBShape::DataResolModF(mass,DataMeanResF[0.5,0.,10.],DataSigmaResF[0.5,0.,10],DataAlphaResF[0.5,0.,10],DataNResF[1.0,1e-06,10]))");
//w->factory("SUM::DataSignalPdfF(fVBP[0.5,0,1]*RooBifurGauss::bifF(mass,DataMeanResF[91.2,80,95],sigmaLF[10,0.5,40],sigmaRF[0.]), RooVoigtian::voigF(mass, DataMeanResF, widthF[2.49], sigmaVoigF[5,0.1,10]) )" );
// composite model pass for MC
w->factory("SUM::McModelP(McNumSgnP*McSignalPdfP,McNumBkgP*McBackgroundPdfP)");
w->factory("SUM::McModelF(McNumSgnF*McSignalPdfF,McNumBkgF*McBackgroundPdfF)");
// composite model pass for data
w->factory("SUM::DataModelP(DataNumSgnP*DataSignalPdfP,DataNumBkgP*DataBackgroundPdfP)");
w->factory("SUM::DataModelF(DataNumSgnF*DataSignalPdfF,DataNumBkgF*DataBackgroundPdfF)");
// simultaneous fir for MC
w->factory("SIMUL::McModel(McPassing,pass=McModelP,fail=McModelF)");
// simultaneous fir for data
w->factory("SIMUL::DataModel(DataPassing,pass=DataModelP,fail=DataModelF)");
w->Print("V");
w->saveSnapshot("clean", w->allVars());
w->loadSnapshot("clean");
/****************** sim fit to soup **************************/
///////////////////////////////////////////////////////////////
TFile *f = new TFile("dummySoup.root","RECREATE");
TTree* cutTreeSoupP = fullTreeSoup->CopyTree(Form("(%s>0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()));
TTree* cutTreeSoupF = fullTreeSoup->CopyTree(Form("(%s<0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()));
RooDataSet McDataP("McDataP","dataset pass for the soup", RooArgSet(*mass), Import( *cutTreeSoupP ) );
RooDataSet McDataF("McDataF","dataset fail for the soup", RooArgSet(*mass), Import( *cutTreeSoupF ) );
RooDataHist McCombData("McCombData","combined data for the soup", RooArgSet(*mass), Index(*(w->cat("McPassing"))), Import("pass", *(McDataP.createHistogram("histoP",*mass)) ), Import("fail",*(McDataF.createHistogram("histoF",*mass)) ) ) ;
RooPlot* McFrameP = 0;
RooPlot* McFrameF = 0;
RooRealVar* McEffFit = 0;
if(makeSoupFit_){
cout << "**************** N bins in mass " << w->var("mass")->getBins() << endl;
RooFitResult* ResMcCombinedFit = w->pdf("McModel")->fitTo(McCombData, Extended(1), Minos(1), Save(1), SumW2Error( SumW2_ ), Range(xLow_,xHigh_), NumCPU(4) /*, ExternalConstraints( *(w->pdf("ConstrainMcNumBkgF")) )*/ );
test->cd(Form("bin%f",binCenter_));
ResMcCombinedFit->Write("McFitResults_Combined");
RooArgSet McFitParam(ResMcCombinedFit->floatParsFinal());
McEffFit = (RooRealVar*)(&McFitParam["McEfficiency"]);
RooRealVar* McNumSigFit = (RooRealVar*)(&McFitParam["McNumSgn"]);
RooRealVar* McNumBkgPFit = (RooRealVar*)(&McFitParam["McNumBkgP"]);
RooRealVar* McNumBkgFFit = (RooRealVar*)(&McFitParam["McNumBkgF"]);
McFrameP = mass->frame(Bins(24),Title("MC: passing sample"));
McCombData.plotOn(McFrameP,Cut("McPassing==McPassing::pass"));
w->pdf("McModel")->plotOn(McFrameP,Slice(*(w->cat("McPassing")),"pass"), ProjWData(*(w->cat("McPassing")),McCombData), LineColor(kBlue),Range(xLow_,xHigh_));
w->pdf("McModel")->plotOn(McFrameP,Slice(*(w->cat("McPassing")),"pass"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McSignalPdfP"), LineColor(kRed),Range(xLow_,xHigh_));
w->pdf("McModel")->plotOn(McFrameP,Slice(*(w->cat("McPassing")),"pass"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McBackgroundPdfP"), LineColor(kGreen),Range(xLow_,xHigh_));
McFrameF = mass->frame(Bins(24),Title("MC: failing sample"));
McCombData.plotOn(McFrameF,Cut("McPassing==McPassing::fail"));
w->pdf("McModel")->plotOn(McFrameF,Slice(*(w->cat("McPassing")),"fail"), ProjWData(*(w->cat("McPassing")),McCombData), LineColor(kBlue),Range(xLow_,xHigh_));
w->pdf("McModel")->plotOn(McFrameF,Slice(*(w->cat("McPassing")),"fail"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McSignalPdfF"), LineColor(kRed),Range(xLow_,xHigh_));
w->pdf("McModel")->plotOn(McFrameF,Slice(*(w->cat("McPassing")),"fail"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McBackgroundPdfF"), LineColor(kGreen),Range(xLow_,xHigh_));
}
///////////////////////////////////////////////////////////////
/****************** sim fit to data **************************/
///////////////////////////////////////////////////////////////
TFile *f2 = new TFile("dummyData.root","RECREATE");
TTree* cutTreeDataP = fullTreeData->CopyTree(Form("(%s>0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()));
TTree* cutTreeDataF = fullTreeData->CopyTree(Form("(%s<0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()));
RooDataSet DataDataP("DataDataP","dataset pass for the soup", RooArgSet(*mass), Import( *cutTreeDataP ) );
RooDataSet DataDataF("DataDataF","dataset fail for the soup", RooArgSet(*mass), Import( *cutTreeDataF ) );
RooDataHist DataCombData("DataCombData","combined data for the soup", RooArgSet(*mass), Index(*(w->cat("DataPassing"))), Import("pass",*(DataDataP.createHistogram("histoDataP",*mass))),Import("fail",*(DataDataF.createHistogram("histoDataF",*mass)))) ;
RooFitResult* ResDataCombinedFit = w->pdf("DataModel")->fitTo(DataCombData, Extended(1), Minos(1), Save(1), SumW2Error( SumW2_ ), Range(xLow_,xHigh_), NumCPU(4));
test->cd(Form("bin%f",binCenter_));
ResDataCombinedFit->Write("DataFitResults_Combined");
RooArgSet DataFitParam(ResDataCombinedFit->floatParsFinal());
RooRealVar* DataEffFit = (RooRealVar*)(&DataFitParam["DataEfficiency"]);
RooRealVar* DataNumSigFit = (RooRealVar*)(&DataFitParam["DataNumSgn"]);
RooRealVar* DataNumBkgPFit = (RooRealVar*)(&DataFitParam["DataNumBkgP"]);
RooRealVar* DataNumBkgFFit = (RooRealVar*)(&DataFitParam["DataNumBkgF"]);
RooPlot* DataFrameP = mass->frame(Bins(24),Title("Data: passing sample"));
DataCombData.plotOn(DataFrameP,Cut("DataPassing==DataPassing::pass"));
w->pdf("DataModel")->plotOn(DataFrameP,Slice(*(w->cat("DataPassing")),"pass"), ProjWData(*(w->cat("DataPassing")),DataCombData), LineColor(kBlue),Range(xLow_,xHigh_));
w->pdf("DataModel")->plotOn(DataFrameP,Slice(*(w->cat("DataPassing")),"pass"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataSignalPdfP"), LineColor(kRed),Range(xLow_,xHigh_));
w->pdf("DataModel")->plotOn(DataFrameP,Slice(*(w->cat("DataPassing")),"pass"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataBackgroundPdfP"), LineColor(kGreen),LineStyle(kDashed),Range(xLow_,xHigh_));
RooPlot* DataFrameF = mass->frame(Bins(24),Title("Data: failing sample"));
DataCombData.plotOn(DataFrameF,Cut("DataPassing==DataPassing::fail"));
w->pdf("DataModel")->plotOn(DataFrameF,Slice(*(w->cat("DataPassing")),"fail"), ProjWData(*(w->cat("DataPassing")),DataCombData), LineColor(kBlue),Range(xLow_,xHigh_));
w->pdf("DataModel")->plotOn(DataFrameF,Slice(*(w->cat("DataPassing")),"fail"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataSignalPdfF"), LineColor(kRed),Range(xLow_,xHigh_));
w->pdf("DataModel")->plotOn(DataFrameF,Slice(*(w->cat("DataPassing")),"fail"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataBackgroundPdfF"), LineColor(kGreen),LineStyle(kDashed),Range(xLow_,xHigh_));
///////////////////////////////////////////////////////////////
if(makeSoupFit_) c->Divide(2,2);
else c->Divide(2,1);
c->cd(1);
DataFrameP->Draw();
c->cd(2);
DataFrameF->Draw();
if(makeSoupFit_){
c->cd(3);
McFrameP->Draw();
c->cd(4);
McFrameF->Draw();
}
c->Draw();
test->cd(Form("bin%f",binCenter_));
c->Write();
c2->Divide(2,1);
c2->cd(1);
TemplateFrameP->Draw();
c2->cd(2);
TemplateFrameF->Draw();
c2->Draw();
test->cd(Form("bin%f",binCenter_));
c2->Write();
// MINOS errors, otherwise HESSE quadratic errors
float McErrorLo = 0;
float McErrorHi = 0;
if(makeSoupFit_){
McErrorLo = McEffFit->getErrorLo()<0 ? McEffFit->getErrorLo() : (-1)*McEffFit->getError();
McErrorHi = McEffFit->getErrorHi()>0 ? McEffFit->getErrorHi() : McEffFit->getError();
}
float DataErrorLo = DataEffFit->getErrorLo()<0 ? DataEffFit->getErrorLo() : (-1)*DataEffFit->getError();
float DataErrorHi = DataEffFit->getErrorHi()>0 ? DataEffFit->getErrorHi() : DataEffFit->getError();
float BinomialError = TMath::Sqrt(SGNtruePass/SGNtrue*(1-SGNtruePass/SGNtrue)/SGNtrue);
Double_t* truthMC = new Double_t[6];
Double_t* tnpMC = new Double_t[6];
Double_t* tnpData = new Double_t[6];
truthMC[0] = binCenter_;
truthMC[1] = binWidth_;
truthMC[2] = binWidth_;
truthMC[3] = SGNtruePass/SGNtrue;
truthMC[4] = BinomialError;
truthMC[5] = BinomialError;
if(makeSoupFit_){
tnpMC[0] = binCenter_;
tnpMC[1] = binWidth_;
tnpMC[2] = binWidth_;
tnpMC[3] = McEffFit->getVal();
tnpMC[4] = (-1)*McErrorLo;
tnpMC[5] = McErrorHi;
}
tnpData[0] = binCenter_;
tnpData[1] = binWidth_;
tnpData[2] = binWidth_;
tnpData[3] = DataEffFit->getVal();
tnpData[4] = (-1)*DataErrorLo;
tnpData[5] = DataErrorHi;
out.push_back(truthMC);
out.push_back(tnpData);
if(makeSoupFit_) out.push_back(tnpMC);
test->Close();
//delete c; delete c2;
if(verbose_) cout << "returning from bin " << bin_ << endl;
return out;
}
void KinZfitter::MakeModel(/*RooWorkspace &w,*/ KinZfitter::FitInput &input, KinZfitter::FitOutput &output) {
//lep
RooRealVar pTRECO1_lep("pTRECO1_lep", "pTRECO1_lep", input.pTRECO1_lep, 5, 500);
RooRealVar pTRECO2_lep("pTRECO2_lep", "pTRECO2_lep", input.pTRECO2_lep, 5, 500);
RooRealVar pTMean1_lep("pTMean1_lep", "pTMean1_lep",
input.pTRECO1_lep, max(5.0, input.pTRECO1_lep-2*input.pTErr1_lep), input.pTRECO1_lep+2*input.pTErr1_lep);
RooRealVar pTMean2_lep("pTMean2_lep", "pTMean2_lep",
input.pTRECO2_lep, max(5.0, input.pTRECO2_lep-2*input.pTErr2_lep), input.pTRECO2_lep+2*input.pTErr2_lep);
RooRealVar pTSigma1_lep("pTSigma1_lep", "pTSigma1_lep", input.pTErr1_lep);
RooRealVar pTSigma2_lep("pTSigma2_lep", "pTSigma2_lep", input.pTErr2_lep);
RooRealVar theta1_lep("theta1_lep", "theta1_lep", input.theta1_lep);
RooRealVar theta2_lep("theta2_lep", "theta2_lep", input.theta2_lep);
RooRealVar phi1_lep("phi1_lep", "phi1_lep", input.phi1_lep);
RooRealVar phi2_lep("phi2_lep", "phi2_lep", input.phi2_lep);
RooRealVar m1("m1", "m1", input.m1);
RooRealVar m2("m2", "m2", input.m2);
//gamma
RooRealVar pTRECO1_gamma("pTRECO1_gamma", "pTRECO1_gamma", input.pTRECO1_gamma, 5, 500);
RooRealVar pTRECO2_gamma("pTRECO2_gamma", "pTRECO2_gamma", input.pTRECO2_gamma, 5, 500);
RooRealVar pTMean1_gamma("pTMean1_gamma", "pTMean1_gamma",
input.pTRECO1_gamma, max(0.5, input.pTRECO1_gamma-2*input.pTErr1_gamma), input.pTRECO1_gamma+2*input.pTErr1_gamma);
RooRealVar pTMean2_gamma("pTMean2_gamma", "pTMean2_gamma",
input.pTRECO2_gamma, max(0.5, input.pTRECO2_gamma-2*input.pTErr2_gamma), input.pTRECO2_gamma+2*input.pTErr2_gamma);
RooRealVar pTSigma1_gamma("pTSigma1_gamma", "pTSigma1_gamma", input.pTErr1_gamma);
RooRealVar pTSigma2_gamma("pTSigma2_gamma", "pTSigma2_gamma", input.pTErr2_gamma);
RooRealVar theta1_gamma("theta1_gamma", "theta1_gamma", input.theta1_gamma);
RooRealVar theta2_gamma("theta2_gamma", "theta2_gamma", input.theta2_gamma);
RooRealVar phi1_gamma("phi1_gamma", "phi1_gamma", input.phi1_gamma);
RooRealVar phi2_gamma("phi2_gamma", "phi2_gamma", input.phi2_gamma);
//gauss
RooGaussian gauss1_lep("gauss1_lep", "gauss1_lep", pTRECO1_lep, pTMean1_lep, pTSigma1_lep);
RooGaussian gauss2_lep("gauss2_lep", "gauss2_lep", pTRECO2_lep, pTMean2_lep, pTSigma2_lep);
RooGaussian gauss1_gamma("gauss1_gamma", "gauss1_gamma", pTRECO1_gamma, pTMean1_gamma, pTSigma1_gamma);
RooGaussian gauss2_gamma("gauss2_gamma", "gauss2_gamma", pTRECO2_gamma, pTMean2_gamma, pTSigma2_gamma);
TString makeE_lep = "TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1)))+@2*@2)";
RooFormulaVar E1_lep("E1_lep", makeE_lep, RooArgList(pTMean1_lep, theta1_lep, m1)); //w.import(E1_lep);
RooFormulaVar E2_lep("E2_lep", makeE_lep, RooArgList(pTMean2_lep, theta2_lep, m2)); //w.import(E2_lep);
TString makeE_gamma = "TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1))))";
RooFormulaVar E1_gamma("E1_gamma", makeE_gamma, RooArgList(pTMean1_gamma, theta1_gamma)); //w.import(E1_gamma);
RooFormulaVar E2_gamma("E2_gamma", makeE_gamma, RooArgList(pTMean2_gamma, theta2_gamma)); //w.import(E2_gamma);
//dotProduct 3d
TString dotProduct_3d = "@0*@1*( ((TMath::Cos(@2))*(TMath::Cos(@3)))/((TMath::Sin(@2))*(TMath::Sin(@3)))+(TMath::Cos(@4-@5)))";
RooFormulaVar p1v3D2("p1v3D2", dotProduct_3d, RooArgList(pTMean1_lep, pTMean2_lep, theta1_lep, theta2_lep, phi1_lep, phi2_lep));
RooFormulaVar p1v3Dph1("p1v3Dph1", dotProduct_3d, RooArgList(pTMean1_lep, pTMean1_gamma, theta1_lep, theta1_gamma, phi1_lep, phi1_gamma));
RooFormulaVar p2v3Dph1("p2v3Dph1", dotProduct_3d, RooArgList(pTMean2_lep, pTMean1_gamma, theta2_lep, theta1_gamma, phi2_lep, phi1_gamma));
RooFormulaVar p1v3Dph2("p1v3Dph2", dotProduct_3d, RooArgList(pTMean1_lep, pTMean2_gamma, theta1_lep, theta2_gamma, phi1_lep, phi2_gamma));
RooFormulaVar p2v3Dph2("p2v3Dph2", dotProduct_3d, RooArgList(pTMean2_lep, pTMean2_gamma, theta2_lep, theta2_gamma, phi2_lep, phi2_gamma));
RooFormulaVar ph1v3Dph2("ph1v3Dph2", dotProduct_3d, RooArgList(pTMean1_gamma, pTMean2_gamma, theta1_gamma, theta2_gamma, phi1_gamma, phi2_gamma));
TString dotProduct_4d = "@0*@1-@2";
RooFormulaVar p1D2("p1D2", dotProduct_4d, RooArgList(E1_lep, E2_lep, p1v3D2)); //w.import(p1D2);
RooFormulaVar p1Dph1("p1Dph1", dotProduct_4d, RooArgList(E1_lep, E1_gamma, p1v3Dph1));// w.import(p1Dph1);
RooFormulaVar p2Dph1("p2Dph1", dotProduct_4d, RooArgList(E2_lep, E1_gamma, p2v3Dph1)); // w.import(p2Dph1);
RooFormulaVar p1Dph2("p1Dph2", dotProduct_4d, RooArgList(E1_lep, E2_gamma, p1v3Dph2)); //w.import(p1Dph2);
RooFormulaVar p2Dph2("p2Dph2", dotProduct_4d, RooArgList(E2_lep, E2_gamma, p2v3Dph2)); //w.import(p2Dph2);
RooFormulaVar ph1Dph2("ph1Dph2", dotProduct_4d, RooArgList(E1_gamma, E2_gamma, ph1v3Dph2)); // w.import(ph1Dph2);
RooRealVar bwMean("bwMean", "m_{Z^{0}}", 91.187); //w.import(bwMean);
RooRealVar bwGamma("bwGamma", "#Gamma", 2.5);
RooProdPdf* PDFRelBW;
RooFormulaVar* mZ;
RooGenericPdf* RelBW;
//mZ
mZ = new RooFormulaVar("mZ", "TMath::Sqrt(2*@0+@1*@1+@2*@2)", RooArgList(p1D2, m1, m2));
RelBW = new RooGenericPdf("RelBW","1/( pow(mZ*mZ-bwMean*bwMean,2)+pow(mZ,4)*pow(bwGamma/bwMean,2) )", RooArgSet(*mZ,bwMean,bwGamma) );
PDFRelBW = new RooProdPdf("PDFRelBW", "PDFRelBW", RooArgList(gauss1_lep, gauss2_lep, *RelBW));
if (input.nFsr == 1) {
mZ = new RooFormulaVar("mZ", "TMath::Sqrt(2*@0+2*@1+2*@2+@3*@3+@4*@4)", RooArgList(p1D2, p1Dph1, p2Dph1, m1, m2));
RelBW = new RooGenericPdf("RelBW","1/( pow(mZ*mZ-bwMean*bwMean,2)+pow(mZ,4)*pow(bwGamma/bwMean,2) )", RooArgSet(*mZ,bwMean,bwGamma) );
// PDFRelBW = new RooProdPdf("PDFRelBW", "PDFRelBW", RooArgList(gauss1_lep, gauss2_lep, gauss1_gamma, *RelBW));
}
if (input.nFsr == 2) {
mZ = new RooFormulaVar("mZ", "TMath::Sqrt(2*@0+2*@1+2*@2+2*@3+2*@4+2*@5+@6*@6+@7*@7)", RooArgList(p1D2,p1Dph1,p2Dph1,p1Dph2,p2Dph2,ph1Dph2, m1, m2));
RelBW = new RooGenericPdf("RelBW","1/( pow(mZ*mZ-bwMean*bwMean,2)+pow(mZ,4)*pow(bwGamma/bwMean,2) )", RooArgSet(*mZ,bwMean,bwGamma) );
// PDFRelBW = new RooProdPdf("PDFRelBW", "PDFRelBW", RooArgList(gauss1_lep, gauss2_lep, gauss1_gamma, gauss2_gamma, *RelBW));
}
//true shape
RooRealVar sg("sg", "sg", sgVal_);
RooRealVar a("a", "a", aVal_);
RooRealVar n("n", "n", nVal_);
RooCBShape CB("CB","CB",*mZ,bwMean,sg,a,n);
RooRealVar f("f","f", fVal_);
RooRealVar mean("mean","mean",meanVal_);
RooRealVar sigma("sigma","sigma",sigmaVal_);
RooRealVar f1("f1","f1",f1Val_);
RooAddPdf *RelBWxCB;
RelBWxCB = new RooAddPdf("RelBWxCB","RelBWxCB", *RelBW, CB, f);
RooGaussian *gauss;
gauss = new RooGaussian("gauss","gauss",*mZ,mean,sigma);
RooAddPdf *RelBWxCBxgauss;
RelBWxCBxgauss = new RooAddPdf("RelBWxCBxgauss","RelBWxCBxgauss", *RelBWxCB, *gauss, f1);
RooProdPdf *PDFRelBWxCBxgauss;
PDFRelBWxCBxgauss = new RooProdPdf("PDFRelBWxCBxgauss","PDFRelBWxCBxgauss",
RooArgList(gauss1_lep, gauss2_lep, *RelBWxCBxgauss) );
//make fit
RooArgSet *rastmp;
rastmp = new RooArgSet(pTRECO1_lep, pTRECO2_lep);
/*
if(input.nFsr == 1) {
rastmp = new RooArgSet(pTRECO1_lep, pTRECO2_lep, pTRECO1_gamma);
}
if(input.nFsr == 2) {
rastmp = new RooArgSet(pTRECO1_lep, pTRECO2_lep, pTRECO1_gamma, pTRECO2_gamma);
}
*/
RooDataSet* pTs = new RooDataSet("pTs","pTs", *rastmp);
pTs->add(*rastmp);
RooFitResult* r;
if (mass4lRECO_ > 140) {
r = PDFRelBW->fitTo(*pTs,RooFit::Save(),RooFit::PrintLevel(-1));
} else {
r = PDFRelBWxCBxgauss->fitTo(*pTs,RooFit::Save(),RooFit::PrintLevel(-1));
}
//save fit result
const TMatrixDSym& covMatrix = r->covarianceMatrix();
const RooArgList& finalPars = r->floatParsFinal();
for (int i=0 ; i<finalPars.getSize(); i++){
TString name = TString(((RooRealVar*)finalPars.at(i))->GetName());
if(debug_) cout<<"name list of RooRealVar for covariance matrix "<<name<<endl;
}
int size = covMatrix.GetNcols();
output.covMatrixZ.ResizeTo(size,size);
output.covMatrixZ = covMatrix;
output.pT1_lep = pTMean1_lep.getVal();
output.pT2_lep = pTMean2_lep.getVal();
output.pTErr1_lep = pTMean1_lep.getError();
output.pTErr2_lep = pTMean2_lep.getError();
/*
if (input.nFsr >= 1) {
output.pT1_gamma = pTMean1_gamma.getVal();
output.pTErr1_gamma = pTMean1_gamma.getError();
}
if (input.nFsr == 2) {
output.pT2_gamma = pTMean2_gamma.getVal();
output.pTErr2_gamma = pTMean2_gamma.getError();
}
*/
delete rastmp;
delete pTs;
delete PDFRelBW;
delete mZ;
delete RelBW;
delete RelBWxCB;
delete gauss;
delete RelBWxCBxgauss;
delete PDFRelBWxCBxgauss;
}
//
// calculation of the limit: assumes that wspace is set up and observations
// contained in data
//
MyLimit computeLimit (RooWorkspace* wspace, RooDataSet* data, StatMethod method, bool draw) {
// let's time this challenging example
TStopwatch t;
//
// get nominal signal
//
RooRealVar exp_sig(*wspace->var("s"));
double exp_sig_val = exp_sig.getVal();
std::cout << "exp_sig = " << exp_sig_val << std::endl;
/////////////////////////////////////////////////////
// Now the statistical tests
// model config
std::cout << wspace->pdf("model") << " "
<< wspace->pdf("prior") << " "
<< wspace->set("poi") << " "
<< wspace->set("nuis") << std::endl;
ModelConfig modelConfig("RA4abcd");
modelConfig.SetWorkspace(*wspace);
modelConfig.SetPdf(*wspace->pdf("model"));
modelConfig.SetPriorPdf(*wspace->pdf("prior"));
modelConfig.SetParametersOfInterest(*wspace->set("poi"));
modelConfig.SetNuisanceParameters(*wspace->set("nuis"));
//////////////////////////////////////////////////
// If you want to see the covariance matrix uncomment
// wspace->pdf("model")->fitTo(*data);
// use ProfileLikelihood
if ( method == ProfileLikelihoodMethod ) {
ProfileLikelihoodCalculator plc(*data, modelConfig);
plc.SetConfidenceLevel(0.95);
RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelow();
RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);
LikelihoodInterval* plInt = plc.GetInterval();
RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);
plInt->LowerLimit( *wspace->var("s") ); // get ugly print out of the way. Fix.
// RooMsgService::instance().setGlobalKillBelow(RooFit::DEBUG);
if ( draw ) {
TCanvas* c = new TCanvas("ProfileLikelihood");
LikelihoodIntervalPlot* lrplot = new LikelihoodIntervalPlot(plInt);
lrplot->Draw();
}
// RooMsgService::instance().setGlobalKillBelow(msglevel);
double lowLim = plInt->LowerLimit(*wspace->var("s"));
double uppLim = plInt->UpperLimit(*wspace->var("s"));
// double exp_sig_val = wspace->var("s")->getVal();
// double exp_sig_val = exp_sig.getVal();
cout << "Profile Likelihood interval on s = [" <<
lowLim << ", " <<
uppLim << "]" << " " << exp_sig_val << endl;
// MyLimit result(plInt->IsInInterval(exp_sig),
MyLimit result(exp_sig_val>lowLim&&exp_sig_val<uppLim,lowLim,uppLim);
// std::cout << "isIn " << result << std::endl;
delete plInt;
// delete modelConfig;
return result;
}
// use FeldmaCousins (takes ~20 min)
if ( method == FeldmanCousinsMethod ) {
FeldmanCousins fc(*data, modelConfig);
fc.SetConfidenceLevel(0.95);
//number counting: dataset always has 1 entry with N events observed
fc.FluctuateNumDataEntries(false);
fc.UseAdaptiveSampling(true);
fc.SetNBins(100);
PointSetInterval* fcInt = NULL;
fcInt = (PointSetInterval*) fc.GetInterval(); // fix cast
double lowLim = fcInt->LowerLimit(*wspace->var("s"));
double uppLim = fcInt->UpperLimit(*wspace->var("s"));
// double exp_sig_val = wspace->var("s")->getVal();
cout << "Feldman Cousins interval on s = [" << lowLim << " " << uppLim << endl;
// std::cout << "isIn " << result << std::endl;
MyLimit result(exp_sig_val>lowLim&&exp_sig_val<uppLim,
fcInt->LowerLimit(*wspace->var("s")),fcInt->UpperLimit(*wspace->var("s")));
delete fcInt;
return result;
}
// use BayesianCalculator (only 1-d parameter of interest, slow for this problem)
if ( method == BayesianMethod ) {
BayesianCalculator bc(*data, modelConfig);
bc.SetConfidenceLevel(0.95);
bc.SetLeftSideTailFraction(0.5);
SimpleInterval* bInt = NULL;
if( wspace->set("poi")->getSize() == 1) {
bInt = bc.GetInterval();
if ( draw ) {
TCanvas* c = new TCanvas("Bayesian");
// the plot takes a long time and print lots of error
// using a scan it is better
bc.SetScanOfPosterior(50);
RooPlot* bplot = bc.GetPosteriorPlot();
bplot->Draw();
}
cout << "Bayesian interval on s = [" <<
bInt->LowerLimit( ) << ", " <<
bInt->UpperLimit( ) << "]" << endl;
// std::cout << "isIn " << result << std::endl;
MyLimit result(bInt->IsInInterval(exp_sig),
bInt->LowerLimit(),bInt->UpperLimit());
delete bInt;
return result;
} else {
cout << "Bayesian Calc. only supports on parameter of interest" << endl;
return MyLimit();
}
}
// use MCMCCalculator (takes about 1 min)
// Want an efficient proposal function, so derive it from covariance
// matrix of fit
if ( method == MCMCMethod ) {
RooFitResult* fit = wspace->pdf("model")->fitTo(*data,Save());
ProposalHelper ph;
ph.SetVariables((RooArgSet&)fit->floatParsFinal());
ph.SetCovMatrix(fit->covarianceMatrix());
ph.SetUpdateProposalParameters(kTRUE); // auto-create mean vars and add mappings
ph.SetCacheSize(100);
ProposalFunction* pf = ph.GetProposalFunction();
MCMCCalculator mc(*data, modelConfig);
mc.SetConfidenceLevel(0.95);
mc.SetProposalFunction(*pf);
mc.SetNumBurnInSteps(100); // first N steps to be ignored as burn-in
mc.SetNumIters(100000);
mc.SetLeftSideTailFraction(0.5); // make a central interval
MCMCInterval* mcInt = NULL;
mcInt = mc.GetInterval();
MCMCIntervalPlot mcPlot(*mcInt);
mcPlot.Draw();
cout << "MCMC interval on s = [" <<
mcInt->LowerLimit(*wspace->var("s") ) << ", " <<
mcInt->UpperLimit(*wspace->var("s") ) << "]" << endl;
// std::cout << "isIn " << result << std::endl;
MyLimit result(mcInt->IsInInterval(exp_sig),
mcInt->LowerLimit(*wspace->var("s")),mcInt->UpperLimit(*wspace->var("s")));
delete mcInt;
return result;
}
t.Print();
// delete modelConfig;
return MyLimit();
}
void accessParams(int n, double array[] ){
/*
RooArgList fl=fitresult->floatParsFinal();
RooArgList cl=fitresult->constPars();
fl.Print();
cl.Print();
int fn=fl.getSize();
int cn=cl.getSize();
*/ // mean,area
RooRealVar* par;
RooRealVar* pas;
if (n==1){
par = (RooRealVar*) fitresult->floatParsFinal().find("mean1");
if (par==NULL){ par = (RooRealVar*) fitresult->constPars().find("mean1"); }
pas = (RooRealVar*) fitresult->floatParsFinal().find("area1");
if (pas==NULL){ pas = (RooRealVar*) fitresult->constPars().find("area1"); }
// printf( " mean1 == %f +- %f\n", par->getVal() , par->getError() );
array[0]= par->getVal(); array[1]= par->getError();
array[2]= pas->getVal(); array[3]= pas->getError();
}
if (npeaks<2) return;
if (n==2){
par = (RooRealVar*) fitresult->floatParsFinal().find("mean2");
if (par==NULL){ par = (RooRealVar*) fitresult->constPars().find("mean2"); }
pas = (RooRealVar*) fitresult->floatParsFinal().find("area2");
if (pas==NULL){ pas = (RooRealVar*) fitresult->constPars().find("area2"); }
// printf( " mean2 == %f +- %f\n", par->getVal() , par->getError() );
array[0]= par->getVal(); array[1]= par->getError();
array[2]= pas->getVal(); array[3]= pas->getError();
}
if (npeaks<3) return;
if (n==3){
par = (RooRealVar*) fitresult->floatParsFinal().find("mean3");
if (par==NULL){ par = (RooRealVar*) fitresult->constPars().find("mean3"); }
pas = (RooRealVar*) fitresult->floatParsFinal().find("area3");
if (pas==NULL){ pas = (RooRealVar*) fitresult->constPars().find("area3"); }
// printf( " mean2 == %f +- %f\n", par->getVal() , par->getError() );
array[0]= par->getVal(); array[1]= par->getError();
array[2]= pas->getVal(); array[3]= pas->getError();
}
if (npeaks<4) return;
if (n==4){
par = (RooRealVar*) fitresult->floatParsFinal().find("mean4");
if (par==NULL){ par = (RooRealVar*) fitresult->constPars().find("mean4"); }
pas = (RooRealVar*) fitresult->floatParsFinal().find("area4");
if (pas==NULL){ pas = (RooRealVar*) fitresult->constPars().find("area4"); }
// printf( " mean2 == %f +- %f\n", par->getVal() , par->getError() );
array[0]= par->getVal(); array[1]= par->getError();
array[2]= pas->getVal(); array[3]= pas->getError();
}
if (npeaks<5) return;
if (n==5){
par = (RooRealVar*) fitresult->floatParsFinal().find("mean5");
if (par==NULL){ par = (RooRealVar*) fitresult->constPars().find("mean5"); }
pas = (RooRealVar*) fitresult->floatParsFinal().find("area5");
if (pas==NULL){ pas = (RooRealVar*) fitresult->constPars().find("area5"); }
// printf( " mean2 == %f +- %f\n", par->getVal() , par->getError() );
array[0]= par->getVal(); array[1]= par->getError();
array[2]= pas->getVal(); array[3]= pas->getError();
}
if (npeaks<6) return;
return;
}//----------access
void rs101_limitexample()
{
// --------------------------------------
// An example of setting a limit in a number counting experiment with uncertainty on background and signal
// to time the macro
TStopwatch t;
t.Start();
// --------------------------------------
// The Model building stage
// --------------------------------------
RooWorkspace* wspace = new RooWorkspace();
wspace->factory("Poisson::countingModel(obs[150,0,300], sum(s[50,0,120]*ratioSigEff[1.,0,3.],b[100]*ratioBkgEff[1.,0.,3.]))"); // counting model
// wspace->factory("Gaussian::sigConstraint(ratioSigEff,1,0.05)"); // 5% signal efficiency uncertainty
// wspace->factory("Gaussian::bkgConstraint(ratioBkgEff,1,0.1)"); // 10% background efficiency uncertainty
wspace->factory("Gaussian::sigConstraint(gSigEff[1,0,3],ratioSigEff,0.05)"); // 5% signal efficiency uncertainty
wspace->factory("Gaussian::bkgConstraint(gSigBkg[1,0,3],ratioBkgEff,0.2)"); // 10% background efficiency uncertainty
wspace->factory("PROD::modelWithConstraints(countingModel,sigConstraint,bkgConstraint)"); // product of terms
wspace->Print();
RooAbsPdf* modelWithConstraints = wspace->pdf("modelWithConstraints"); // get the model
RooRealVar* obs = wspace->var("obs"); // get the observable
RooRealVar* s = wspace->var("s"); // get the signal we care about
RooRealVar* b = wspace->var("b"); // get the background and set it to a constant. Uncertainty included in ratioBkgEff
b->setConstant();
RooRealVar* ratioSigEff = wspace->var("ratioSigEff"); // get uncertain parameter to constrain
RooRealVar* ratioBkgEff = wspace->var("ratioBkgEff"); // get uncertain parameter to constrain
RooArgSet constrainedParams(*ratioSigEff, *ratioBkgEff); // need to constrain these in the fit (should change default behavior)
RooRealVar * gSigEff = wspace->var("gSigEff"); // global observables for signal efficiency
RooRealVar * gSigBkg = wspace->var("gSigBkg"); // global obs for background efficiency
gSigEff->setConstant();
gSigBkg->setConstant();
// Create an example dataset with 160 observed events
obs->setVal(160.);
RooDataSet* data = new RooDataSet("exampleData", "exampleData", RooArgSet(*obs));
data->add(*obs);
RooArgSet all(*s, *ratioBkgEff, *ratioSigEff);
// not necessary
modelWithConstraints->fitTo(*data, RooFit::Constrain(RooArgSet(*ratioSigEff, *ratioBkgEff)));
// Now let's make some confidence intervals for s, our parameter of interest
RooArgSet paramOfInterest(*s);
ModelConfig modelConfig(wspace);
modelConfig.SetPdf(*modelWithConstraints);
modelConfig.SetParametersOfInterest(paramOfInterest);
modelConfig.SetNuisanceParameters(constrainedParams);
modelConfig.SetObservables(*obs);
modelConfig.SetGlobalObservables( RooArgSet(*gSigEff,*gSigBkg));
modelConfig.SetName("ModelConfig");
wspace->import(modelConfig);
wspace->import(*data);
wspace->SetName("w");
wspace->writeToFile("rs101_ws.root");
// First, let's use a Calculator based on the Profile Likelihood Ratio
//ProfileLikelihoodCalculator plc(*data, *modelWithConstraints, paramOfInterest);
ProfileLikelihoodCalculator plc(*data, modelConfig);
plc.SetTestSize(.05);
ConfInterval* lrinterval = plc.GetInterval(); // that was easy.
// Let's make a plot
TCanvas* dataCanvas = new TCanvas("dataCanvas");
dataCanvas->Divide(2,1);
dataCanvas->cd(1);
LikelihoodIntervalPlot plotInt((LikelihoodInterval*)lrinterval);
plotInt.SetTitle("Profile Likelihood Ratio and Posterior for S");
plotInt.Draw();
// Second, use a Calculator based on the Feldman Cousins technique
FeldmanCousins fc(*data, modelConfig);
fc.UseAdaptiveSampling(true);
fc.FluctuateNumDataEntries(false); // number counting analysis: dataset always has 1 entry with N events observed
fc.SetNBins(100); // number of points to test per parameter
fc.SetTestSize(.05);
// fc.SaveBeltToFile(true); // optional
ConfInterval* fcint = NULL;
fcint = fc.GetInterval(); // that was easy.
RooFitResult* fit = modelWithConstraints->fitTo(*data, Save(true));
// Third, use a Calculator based on Markov Chain monte carlo
// Before configuring the calculator, let's make a ProposalFunction
// that will achieve a high acceptance rate
ProposalHelper ph;
ph.SetVariables((RooArgSet&)fit->floatParsFinal());
ph.SetCovMatrix(fit->covarianceMatrix());
ph.SetUpdateProposalParameters(true);
ph.SetCacheSize(100);
ProposalFunction* pdfProp = ph.GetProposalFunction(); // that was easy
MCMCCalculator mc(*data, modelConfig);
mc.SetNumIters(20000); // steps to propose in the chain
mc.SetTestSize(.05); // 95% CL
mc.SetNumBurnInSteps(40); // ignore first N steps in chain as "burn in"
mc.SetProposalFunction(*pdfProp);
mc.SetLeftSideTailFraction(0.5); // find a "central" interval
MCMCInterval* mcInt = (MCMCInterval*)mc.GetInterval(); // that was easy
// Get Lower and Upper limits from Profile Calculator
cout << "Profile lower limit on s = " << ((LikelihoodInterval*) lrinterval)->LowerLimit(*s) << endl;
cout << "Profile upper limit on s = " << ((LikelihoodInterval*) lrinterval)->UpperLimit(*s) << endl;
// Get Lower and Upper limits from FeldmanCousins with profile construction
if (fcint != NULL) {
double fcul = ((PointSetInterval*) fcint)->UpperLimit(*s);
double fcll = ((PointSetInterval*) fcint)->LowerLimit(*s);
cout << "FC lower limit on s = " << fcll << endl;
cout << "FC upper limit on s = " << fcul << endl;
TLine* fcllLine = new TLine(fcll, 0, fcll, 1);
TLine* fculLine = new TLine(fcul, 0, fcul, 1);
fcllLine->SetLineColor(kRed);
fculLine->SetLineColor(kRed);
fcllLine->Draw("same");
fculLine->Draw("same");
dataCanvas->Update();
}
// Plot MCMC interval and print some statistics
MCMCIntervalPlot mcPlot(*mcInt);
mcPlot.SetLineColor(kMagenta);
mcPlot.SetLineWidth(2);
mcPlot.Draw("same");
double mcul = mcInt->UpperLimit(*s);
double mcll = mcInt->LowerLimit(*s);
cout << "MCMC lower limit on s = " << mcll << endl;
cout << "MCMC upper limit on s = " << mcul << endl;
cout << "MCMC Actual confidence level: "
<< mcInt->GetActualConfidenceLevel() << endl;
// 3-d plot of the parameter points
dataCanvas->cd(2);
// also plot the points in the markov chain
RooDataSet * chainData = mcInt->GetChainAsDataSet();
assert(chainData);
std::cout << "plotting the chain data - nentries = " << chainData->numEntries() << std::endl;
TTree* chain = RooStats::GetAsTTree("chainTreeData","chainTreeData",*chainData);
assert(chain);
chain->SetMarkerStyle(6);
chain->SetMarkerColor(kRed);
chain->Draw("s:ratioSigEff:ratioBkgEff","nll_MarkovChain_local_","box"); // 3-d box proportional to posterior
// the points used in the profile construction
RooDataSet * parScanData = (RooDataSet*) fc.GetPointsToScan();
assert(parScanData);
std::cout << "plotting the scanned points used in the frequentist construction - npoints = " << parScanData->numEntries() << std::endl;
// getting the tree and drawing it -crashes (very strange....);
// TTree* parameterScan = RooStats::GetAsTTree("parScanTreeData","parScanTreeData",*parScanData);
// assert(parameterScan);
// parameterScan->Draw("s:ratioSigEff:ratioBkgEff","","goff");
TGraph2D *gr = new TGraph2D(parScanData->numEntries());
for (int ievt = 0; ievt < parScanData->numEntries(); ++ievt) {
const RooArgSet * evt = parScanData->get(ievt);
double x = evt->getRealValue("ratioBkgEff");
double y = evt->getRealValue("ratioSigEff");
double z = evt->getRealValue("s");
gr->SetPoint(ievt, x,y,z);
// std::cout << ievt << " " << x << " " << y << " " << z << std::endl;
}
gr->SetMarkerStyle(24);
gr->Draw("P SAME");
delete wspace;
delete lrinterval;
delete mcInt;
delete fcint;
delete data;
// print timing info
t.Stop();
t.Print();
}
int main(){
BaBarStyle p;
p.SetBaBarStyle();
//gROOT->SetStyle("Plain");
Bool_t doNorm = kTRUE;
Bool_t doComparison = kFALSE;
Bool_t doFract = kFALSE;
Bool_t doFit = kFALSE;
Bool_t doPlots = kFALSE;
//define DalitzSpace for generation
EvtPDL pdl;
pdl.readPDT("evt.pdl");
EvtDecayMode mode("D0 -> K- pi+ pi0");
EvtDalitzPlot dalitzSpace(mode);
RooRealVar m2Kpi_d0mass("m2Kpi_d0mass","m2Kpi_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AB),dalitzSpace.qAbsMax(EvtCyclic3::AB));
RooRealVar m2Kpi0_d0mass("m2Kpi0_d0mass","m2Kpi0_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AC),dalitzSpace.qAbsMax(EvtCyclic3::AC));
RooRealVar m2pipi0_d0mass("m2pipi0_d0mass","m2pipi0_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::BC),dalitzSpace.qAbsMax(EvtCyclic3::BC));
RooCategory D0flav("D0flav","D0flav");
D0flav.defineType("D0",-1);
D0flav.defineType("antiD0",1);
//this is just to plot the m23 pdf
Float_t total = pow(dalitzSpace.bigM(),2) + pow(dalitzSpace.mA(),2) + pow(dalitzSpace.mB(),2) + pow(dalitzSpace.mC(),2);
RooRealVar totalm("totalm","totalm",total);
RooFormulaVar mass13a("mass13a","@0-@1-@2",RooArgSet(totalm,m2Kpi_d0mass,m2pipi0_d0mass));
cout << "read the dataset" << endl;
TFile hello("DataSet_out_tmp.root");
gROOT->cd();
RooDataSet *data = (RooDataSet*)hello.Get("fulldata");
RooDataSet *data_1 = (RooDataSet*)data->reduce("D0flav == 1 && isWS == 0 && d0LifetimeErr < 0.5 && d0Lifetime > -2. && d0Lifetime < 4.");
RooDataSet *finaldata = (RooDataSet*)data_1->reduce("deltaMass > 0.1449 && deltaMass < 0.1459 && d0Mass > 1.8495 && d0Mass < 1.8795");
RooDataSet *leftdata = (RooDataSet*)(RooDataSet*)data_1->reduce("d0Mass > 1.74 && d0Mass < 1.79");
RooDataSet *rightdata = (RooDataSet*)data_1->reduce("d0Mass > 1.94 && d0Mass < 1.99");
//here we set the weights for the dataset
finaldata->setWeightVar(0);
leftdata->setWeightVar(0);
rightdata->setWeightVar(0);
//if you want to have a little dataset to test, uncomment next line and rename finaldata above
//RooDataSet *finaldata = finaldata_1->reduce(EventRange(1,1000));
cout << "*************************************************************" << endl;
cout << "The final data entry " << finaldata->numEntries() << endl;
cout << "*************************************************************" << endl;
//Construct signal pdf
string dirname = "configmaps/effmapping_RS_CP/";
RooKpipi0pdf *D0pdf = new RooKpipi0pdf("D0pdf","D0pdf",m2Kpi_d0mass,m2Kpi0_d0mass,&dalitzSpace,dirname,1);
RooKpipi0pdf *D0pdf23 = new RooKpipi0pdf("D0pdf23","D0pdf23",m2Kpi_d0mass,mass13a,&dalitzSpace,dirname,1);
if(doNorm) D0pdf->getManager()->calNorm();
//When we plot the 1D projection, need to calculate the 1D integral
//set the precision here
//cout << "config integrator " << endl;
RooNumIntConfig *cfg = RooAbsReal::defaultIntegratorConfig();
cfg->setEpsAbs(1E-3);
cfg->setEpsRel(1E-3);
cfg->method1D().setLabel("RooSegmentedIntegrator1D");
//cfg.getConfigSection("RooSegmentedIntegrator1D").setRealValue("numSeg",3);
//cfg->method1D()->Print("v");
D0pdf->setIntegratorConfig(*cfg);
D0pdf23->setIntegratorConfig(*cfg);
cout << "about to init" << endl;
m2Kpi_d0mass.setBins(150);
m2Kpi0_d0mass.setBins(150);
m2pipi0_d0mass.setBins(150);
//background description
//RooBkg combdalitz("combdalitz","combdalitz",m2Kpi_d0mass,m2Kpi0_d0mass,&dalitzSpace);
//RooBkg combdalitz23("combdalitz23","combdalitz23",m2Kpi_d0mass,mass13a,&dalitzSpace);
RooRealVar Nsig("Nsig","Nsig", 653962. + 2218.);
RooRealVar Nbkg("Nbkg","Nbkg", 2255. + 551.);
RooDataHist* dbdalitz = new RooDataHist("dbdalitz","dbdalitz",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*finaldata);
RooDataHist* dbdalitz23 = new RooDataHist("dbdalitz23","dbdalitz23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*finaldata);
////////////////////////////////////////
//background parametrization using sidebands histograms
////////////////////////////////////////
TH2F *lefth = m2Kpi_d0mass.createHistogram("lefth",m2Kpi0_d0mass);
leftdata->fillHistogram(lefth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass));
TH2F *righth = m2Kpi_d0mass.createHistogram("righth",m2Kpi0_d0mass);
rightdata->fillHistogram(righth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass));
TH2F *lefth23 = m2Kpi_d0mass.createHistogram("lefth23",m2pipi0_d0mass);
leftdata->fillHistogram(lefth23,RooArgList(m2Kpi_d0mass,m2pipi0_d0mass));
TH2F *righth23 = m2Kpi_d0mass.createHistogram("righth23",m2pipi0_d0mass);
rightdata->fillHistogram(righth23,RooArgList(m2Kpi_d0mass,m2pipi0_d0mass));
righth->Scale(lefth->Integral()/righth->Integral());
lefth->Sumw2();
righth->Sumw2();
righth23->Scale(lefth23->Integral()/righth23->Integral());
lefth23->Sumw2();
righth23->Sumw2();
RooDataHist *lefthist = new RooDataHist("lefthist","lefthist",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),lefth);
RooDataHist *righthist = new RooDataHist("righthist","righthist",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),righth);
RooDataHist *lefthist23 = new RooDataHist("lefthist23","lefthist23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),lefth23);
RooDataHist *righthist23 = new RooDataHist("righthist23","righthist23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),righth23);
RooHistPdf leftpdf("leftpdf","leftpdf",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*lefthist,4);
RooHistPdf rightpdf("rightpdf","rightpdf",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*righthist,4);
RooHistPdf leftpdf23("leftpdf23","leftpdf23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*lefthist23,4);
RooHistPdf rightpdf23("rightpdf23","rightpdf23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*righthist23,4);
RooRealVar fcomb("fcomb","fcomb",0.738);
RooAddPdf combdalitz("combdalitz","combdalitz",RooArgList(leftpdf,rightpdf),RooArgList(fcomb));
RooAddPdf combdalitz23("combdalitz23","combdalitz23",RooArgList(leftpdf23,rightpdf23),RooArgList(fcomb));
///////////////////////////////////////
RooAddPdf totpdf("totpdf","totpdf",RooArgList(*D0pdf,combdalitz),RooArgList(Nsig,Nbkg));
RooAddPdf totpdf23("totpdf23","totpdf23",RooArgList(*D0pdf23,combdalitz23),RooArgList(Nsig,Nbkg));
if(doFit){
// Start Minuit session on Chi2
RooChi2Var chi2("chi2","chi2",totpdf,*dbdalitz);
RooMinuit m2(chi2);
m2.migrad();
m2.hesse();
RooFitResult* fitRes = m2.save();
fitRes->Print("v");
RooArgSet results(fitRes->floatParsFinal());
RooArgSet conresults(fitRes->constPars());
results.add(conresults);
results.writeToFile("fit_isobar_RS.txt");
//save the stupid result
TFile f("fit_RSDalitz_result.root","RECREATE");
fitRes->Write();
f.Close();
}
if(doFract) {
cout << "Calculating fit fractions" << endl;
TFile f("fit_RSDalitz_result.root");
RooFitResult* fitRes = (RooFitResult*)f.Get("chi2");
//now calculate the fit fractions
const Int_t nRes = D0pdf->getManager()->getnRes();
//recalculate the normalization if necessary
D0pdf->getManager()->calNorm();
EvtComplex normarray[nRes][nRes];
const Int_t myRes = 12;
TH1F fitty[myRes];
//read the integral value from the cache file.
//In this way we don't need to compute the normalization everytime during MIGRAD
char int_name[50];
D0pdf->getManager()->getFileName(int_name);
ifstream f1;
f1.open(int_name);
if (!f1){
cout << "Error opening file " << endl;
assert(0);
}
Double_t re=0.,im=0.;
//Read in the cache file and store back to array
for(Int_t j=0;j<nRes;j++) {
char thname[100];
sprintf(thname,"thname_%d",j);
if(j < myRes) fitty[j] = TH1F(thname,thname,30,0.,1.);
for(Int_t k=0;k<nRes;k++){
f1 >> re >> im;
normarray[j][k] = EvtComplex(re,im);
}
}
EvtComplex mynorm[myRes][myRes];
Int_t m = 0, l = 0;
for(Int_t i=0;i<myRes;i++){
for(Int_t j=0;j<myRes;j++){
if(i==0) l = 7;
else if(i==1) l = 6;
else if(i==2) l = 11;
else if(i==3) l = 4;
else if(i==4) l = 5;
else if(i==5) l = 3;
else if(i==6) l = 9;
else if(i==7) l = 10;
else if(i==8) l = 12;
else if(i==9) l = 8;
else if(i==10) l = 2;
else if(i==11) l = 0;
if(j==0) m = 7;
else if(j==1) m = 6;
else if(j==2) m = 11;
else if(j==3) m = 4;
else if(j==4) m = 5;
else if(j==5) m = 3;
else if(j==6) m = 9;
else if(j==7) m = 10;
else if(j==8) m = 12;
else if(j==9) m = 8;
else if(j==10) m = 2;
else if(j==11) m = 0;
mynorm[i][j] = normarray[l][m];
}
}
//do 100 experiments and extract parameters using covariance matrix
for(Int_t l=0;l<300;l++){
RooArgList listpar = fitRes->randomizePars();
if(l==0) listpar.Print();
Double_t mynormD0 = 0.;
EvtComplex coeff_i(0.,0.), coeff_j(0.,0.);
for(Int_t i=0;i<2*myRes;i++){
for(Int_t j=0;j<2*myRes;j++){
if(i==(2*myRes - 2)) coeff_i = EvtComplex(1.,0.);
else coeff_i = EvtComplex(((RooAbsReal*)listpar.at(i))->getVal()*cos(((RooAbsReal*)listpar.at(i+1))->getVal()),
((RooAbsReal*)listpar.at(i))->getVal()*sin(((RooAbsReal*)listpar.at(i+1))->getVal()));
if(j==(2*myRes - 2)) coeff_j = EvtComplex(1.,0.);
else coeff_j = EvtComplex(((RooAbsReal*)listpar.at(j))->getVal()*cos(((RooAbsReal*)listpar.at(j+1))->getVal()),
((RooAbsReal*)listpar.at(j))->getVal()*sin(((RooAbsReal*)listpar.at(j+1))->getVal()));
mynormD0 += real(coeff_i*conj(coeff_j)*(mynorm[i/2][j/2]));
j++;
}
i++;
}
//now calculate the fit fractions
for(Int_t i=0;i<2*myRes;i++){
Double_t fitfrac = 0.;
if(i==(2*myRes - 2)) fitfrac = abs(mynorm[i/2][i/2])/mynormD0;
else fitfrac = abs2( ((RooAbsReal*)listpar.at(i))->getVal())*abs(mynorm[i/2][i/2])/mynormD0;
fitty[i/2].Fill(fitfrac);
i++;
}
}// nexperiments
Double_t tot_frac = 0.;
for(Int_t i=0;i<myRes;i++){
tot_frac += fitty[i].GetMean();
cout << "Resonance " << i << ": fit fraction = " << fitty[i].GetMean() << " +/- " << fitty[i].GetRMS() << endl;
}
cout << "Total fit fraction = " << tot_frac << endl;
cout << "///////////////////////////" << endl;
}
if(doPlots){
//Make the plots
// REMEBER: if you want roofit to consider the reweighted errors, you must put DataError(RooAbsData::SumW2))
//******************************************************
RooPlot* xframe = m2Kpi_d0mass.frame();
dbdalitz->plotOn(xframe,MarkerSize(0.1),DrawOption("z"));
totpdf.plotOn(xframe);
xframe->getAttLine()->SetLineWidth(1);
xframe->getAttLine()->SetLineStyle(1);
xframe->SetTitle("");
xframe->GetXaxis()->SetTitle("s_{12} [GeV^{2}/c^{4}]");
xframe->GetYaxis()->SetTitle("Events/4 MeV^{2}/c^{4}");
Double_t chi2Kpi = xframe->chiSquare();
RooPlot* yframe = m2Kpi0_d0mass.frame();
dbdalitz->plotOn(yframe,MarkerSize(0.1),DrawOption("z"));
totpdf.plotOn(yframe);
yframe->getAttLine()->SetLineWidth(1);
yframe->getAttLine()->SetLineStyle(1);
yframe->SetTitle("");
yframe->GetXaxis()->SetTitle("s_{13} [GeV^{2}/c^{4}]");
yframe->GetYaxis()->SetTitle("Events/5 MeV^{2}/c^{4}");
Double_t chi2Kpi0 = yframe->chiSquare();
/*
RooPlot* zframe = m2pipi0_d0mass.frame(0.,2.3);
dbdalitz23->plotOn(zframe,MarkerSize(0.1),DrawOption("z"));
totpdf23.plotOn(zframe);
zframe->getAttLine()->SetLineWidth(1);
zframe->getAttLine()->SetLineStyle(1);
zframe->SetTitle("");
zframe->GetXaxis()->SetTitle("m^{2}_{#pi^{+}#pi^{0}}");
Double_t chi2pipi0 = zframe->chiSquare();
cout << "Chi2 for Kpi = " << chi2Kpi << endl;
cout << "Chi2 for Kpi0 = " << chi2Kpi0 << endl;
cout << "Chi2 for pipi0 = " << chi2pipi0 << endl;
RooPlot* pullFramem12 = m2Kpi_d0mass.frame() ;
pullFramem12->SetTitle("");
pullFramem12->GetXaxis()->SetTitle("");
pullFramem12->addPlotable(xframe->pullHist()) ;
pullFramem12->SetMaximum(5.);
pullFramem12->SetMinimum(-5.);
RooPlot* pullFramem13 = m2Kpi0_d0mass.frame() ;
pullFramem13->SetTitle("");
pullFramem13->GetXaxis()->SetTitle("");
pullFramem13->addPlotable(yframe->pullHist()) ;
pullFramem13->SetMaximum(5.);
pullFramem13->SetMinimum(-5.);
RooPlot* pullFramem23 = m2pipi0_d0mass.frame() ;
pullFramem23->SetTitle("");
pullFramem23->GetXaxis()->SetTitle("");
pullFramem23->addPlotable(zframe->pullHist()) ;
pullFramem23->SetMaximum(5.);
pullFramem23->SetMinimum(-5.);
TCanvas *c2 = new TCanvas("c2","residuals",1200,200);
c2->Divide(3,1);
c2->cd(1);pullFramem12->Draw();
c2->cd(2);pullFramem13->Draw();
c2->cd(3);pullFramem23->Draw();
c2->SaveAs("RSresiduals.eps");
*/
totpdf.plotOn(xframe,Project(m2Kpi0_d0mass),Components(RooArgSet(combdalitz)),DrawOption("F"),FillColor(kRed));
totpdf.plotOn(yframe,Project(m2Kpi_d0mass),Components(RooArgSet(combdalitz)),DrawOption("F"),FillColor(kRed));
//totpdf23.plotOn(zframe,Project(m2Kpi_d0mass),Components(RooArgSet(combdalitz23)),DrawOption("F"),FillColor(kRed));
TPaveText *box_m12 = new TPaveText(2.5,2.5,2.7,2.7,"");
box_m12->AddText("(b)");
box_m12->SetFillColor(10);
TPaveText *box_m13 = new TPaveText(2.5,2.5,2.7,2.7,"");
box_m13->AddText("(c)");
box_m13->SetFillColor(10);
TCanvas c1("c1","c1",600,600);
c1.cd();
xframe->Draw();box_m12->Draw("SAME");
c1.SaveAs("RSfit_m2Kpi.eps");
TCanvas c2("c2","c2",600,600);
c2.cd();
yframe->Draw();box_m13->Draw("SAME");
c2.SaveAs("RSfit_m2Kpi0.eps");
/*
TCanvas *c1 = new TCanvas("c1","allevents",1200,400);
c1->Divide(3,1);
c1->cd(1);xframe->Draw();
//p.SetBaBarLabel(-1,-1,-1,"preliminary");
c1->cd(2);yframe->Draw();
//p.SetBaBarLabel(-1,-1,-1,"preliminary");
c1->cd(3);zframe->Draw();
//p.SetBaBarLabel(-1,-1,-1,"preliminary");
c1->SaveAs("RSsigfit.eps");
*/
}
if(doComparison){
RooDataSet *littledata = (RooDataSet*)finaldata->reduce(EventRange(1,70000));
RooArgSet VarList1(m2Kpi_d0mass,m2Kpi0_d0mass);
Int_t num_entries = littledata->numEntries();
RooDataSet* genpdf = D0pdf->generate(VarList1,num_entries);
Int_t nbinx = 20;
Int_t nbiny = 20;
m2Kpi_d0mass.setBins(nbinx);
m2Kpi0_d0mass.setBins(nbiny);
TH2F* pdfhist = new TH2F("pdfhist","pdfhist",nbinx,0.39,3.,nbiny,0.39,3.);
TH2F* datahist = new TH2F("datahist","datahist",nbinx,0.39,3.,nbiny,0.39,3.);
pdfhist = genpdf->createHistogram(m2Kpi_d0mass,m2Kpi0_d0mass);
datahist = finaldata->createHistogram(m2Kpi_d0mass,m2Kpi0_d0mass);
pdfhist->GetXaxis()->SetTitle("m_{K#pi}^{2}");
pdfhist->GetYaxis()->SetTitle("m_{K#pi^{0}}^{2}");
pdfhist->Scale(datahist->Integral()/pdfhist->Integral());
pdfhist->Add(datahist,-1.);
TCanvas c2;
c2.cd();pdfhist->Draw("LEGO2Z");
c2.SaveAs("RSsigdiff.eps");
TFile ftmp("prova.root","RECREATE");
ftmp.cd();pdfhist->Write();
ftmp.Close();
}
return 0;
}//end of the macro
void PDF_GLWADS_DKDpi_K3pi::setUncertainties(config c)
{
switch(c)
{
case lumi1fb:{
obsErrSource = "1fb-1, ExpNll/sept2012K3PIResult.root";
TString File = this->dir+"/ExpNll/sept2012K3PIResult.root";
TFile *fr = TFile::Open(File);
RooFitResult *r = (RooFitResult*)fr->Get("fitresult_model_reducedData_binned");
assert(r);
for ( int i=0; i<nObs; i++ )
{
RooRealVar* pObs = (RooRealVar*)((RooArgList*)observables)->at(i);
RooRealVar* pRes = (RooRealVar*)r->floatParsFinal().find(obsTmkToMalcolm(pObs->GetName()));
assert(pRes);
StatErr[i] = pRes->getError();
}
SystErr[0] = 0.0026; // rkp_k3pi_obs
SystErr[1] = 0.018; // afav_dk_obs
SystErr[2] = 0.010; // afav_dpi_obs
SystErr[3] = 0.0010; // rp_dk_obs
SystErr[4] = 0.0008; // rm_dk_obs
SystErr[5] = 0.00011; // rp_dpi_obs
SystErr[6] = 0.00011; // rm_dpi_obs
fr->Close();
delete r;
delete fr;
break;
}
case lumi3fb:{
obsErrSource = "3fb-1 ANA v7 unblind"; // https://twiki.cern.ch/twiki/pub/LHCbPhysics/B2D0K/LHCb-ANA-2014-071-v7.pdf (see Vavas email 04/08/15)
// these get transformed over from the new inputs using ExpNll/transportGLWADS_new_to_old.py
// in the case of the DK only (robust) combination some of the observables don't exist
// usemap as the temp store
std::map< TString, double > stat_errs;
stat_errs["rkp_k3pi_obs"] = 0.0010; // rkp_k3pi_obs
stat_errs["afav_dk_k3pi_obs"] = 0.0119; // afav_dk_obs
stat_errs["afav_dpi_k3pi_obs"] = 0.1; // afav_dpi_obs // now Aprod, large error to disable it
stat_errs["rp_dk_k3pi_obs"] = 0.002421; // rp_dk_obs
stat_errs["rm_dk_k3pi_obs"] = 0.001756; // rm_dk_obs
stat_errs["rp_dpi_k3pi_obs"] = 0.000252; // rp_dpi_obs
stat_errs["rm_dpi_k3pi_obs"] = 0.000258; // rm_dpi_obs
for ( int i=0; i<nObs; i++ )
{
RooRealVar* pObs = (RooRealVar*)((RooArgList*)observables)->at(i);
StatErr[i] = stat_errs[pObs->GetName()];
}
stat_errs.clear();
std::map< TString, double > syst_errs;
syst_errs["rkp_k3pi_obs"] = 0.0170; // rkp_k3pi_obs
syst_errs["afav_dk_k3pi_obs"] = 0.0019; // afav_dk_obs
syst_errs["afav_dpi_k3pi_obs"] = 0.1; // afav_dpi_obs // now Aprod, large error to disable it
syst_errs["rp_dk_k3pi_obs"] = 0.000950; // rp_dk_obs
syst_errs["rm_dk_k3pi_obs"] = 0.000673; // rm_dk_obs
syst_errs["rp_dpi_k3pi_obs"] = 0.000061; // rp_dpi_obs
syst_errs["rm_dpi_k3pi_obs"] = 0.000064; // rm_dpi_obs
for ( int i=0; i<nObs; i++ )
{
RooRealVar* pObs = (RooRealVar*)((RooArgList*)observables)->at(i);
SystErr[i] = syst_errs[pObs->GetName()];
}
syst_errs.clear();
break;
}
case lumi9fb:{
setUncertainties(lumi3fb);
obsErrSource = "9fb-1 errors obtained from scaling down the 3fb-1 errors (lumi3fb)";
for ( int i=0; i<nObs; i++ ){
StatErr[i] /= (sqrt(2.7));
SystErr[i] /= (sqrt(2.7));
}
break;
}
default:{
cout << "PDF_GLWADS_DKDpi_K3pi::setUncertainties() : ERROR : config "+ConfigToTString(c)+" not found." << endl;
exit(1);
}
}
}
void fitPtOverMCJLST(int mass = 125, int LHCsqrts = 7, int whichtype = 1,
bool correctErrors = false, /* string changeParName = "", */
bool showErrorPDFs = false, string systString = "Default")
// whichtype
// 0 - gg Signal
// 1 - VBF Signal
// 2 - ZZ
// 3 - ZX
// 4 - ggZZ
// 5 - WH
// 6 - ZH
// 7 - ttH
{
string changeParName = "";
if (systString == "Default") changeParName = "up";
string nameSample[8] = {"gg","vbf","zz","zx","ggzz","wh","zh","tth"};
float maxType[8] = {2.4,3.2,1.6,1.6,1.6,3.2,3.2,3.2};
float rebinType[8] = {1,2,1,1,4,10,10,40};
for (int t = 0; t < 8; t++) {
if (mass > 150) maxType[t] = int(117.90*maxType[t]/sqrt(mass-10.91))/10.;
}
char fileToOpen[200];
sprintf(fileToOpen,"selRootFiles/PToverM_%s%d_SEL_%dTeV.root",nameSample[whichtype].c_str(),mass,LHCsqrts);
// if (whichtype == 3) sprintf(fileToOpen,"PTOVERM_%s_SEL_allTeV.root",nameSample[whichtype].c_str());
RooRealVar* ptoverm = new RooRealVar("ptoverm","p_{T}/M^{4l}",0.,maxType[whichtype],"GeV/c");
TFile input(fileToOpen);
// if (systString == "Mass" || systString == "Mela") {
// sprintf(fileToOpen,"ptovermH_%sUp",systString.c_str());
// } else {
sprintf(fileToOpen,"ptovermH_%s",systString.c_str());
//}
TH1F* ptovermH = (TH1F*)input.Get(fileToOpen);
if (rebinType[whichtype] > 1) ptovermH->Rebin(rebinType[whichtype]);
if (maxType[whichtype] < ptovermH->GetBinLowEdge(ptovermH->GetNbinsX() + 1) - ptovermH->GetBinWidth(1)) {
int theBin = ptovermH->FindBin(maxType[whichtype]);
ptovermH->GetXaxis()->SetRange(1,theBin-1);
}
gROOT->ProcessLine(".L mytdrstyle.C");
gROOT->ProcessLine("setTDRStyle()");
// cout << endl << "Signal " << endl;
ptoverm->setBins(ptovermH->GetNbinsX());
RooDataHist* rdh = new RooDataHist("rdh","Some dataset",RooArgList(*ptoverm),Import(*ptovermH,kFALSE));
// fit definitions
// RooWorkspace *ws = new RooWorkspace("ws");
RooRealVar m("m","emme", 1.,0.01, 40.);
RooRealVar n("n","enne", 0.93, 0.05, 15.);
RooRealVar n2("n2","enne2", 0.75, 0.5, 15.);
RooRealVar bb("bb","bibi",0.02, 0.000005, 20.0);
RooRealVar T("T","tti",0.2,0.00000005,1.);
RooRealVar bb2("bb2","bibi2",0.02, 0.0005, 10.0);
RooRealVar fexp("fexp","f_exp",0.02, 0.0, 1.0);
if (whichtype == 0) {
if (LHCsqrts == 8) {
m.setVal(3.319); // m.setConstant(kTRUE);
n.setVal(0.7606); if (systString != "Default" || mass != 125) n.setConstant(kTRUE);
n2.setVal(0.8061); n2.setConstant(kTRUE);
bb.setVal(3.728); // bb.setConstant(kTRUE);
T.setVal(0.00333); // T.setConstant(kTRUE);
bb2.setVal(1.7172); // bb2.setConstant(kTRUE);
fexp.setVal(0.002144); if (systString != "Default" || mass != 125) fexp.setConstant(kTRUE);
} else {
m.setVal(0.061); // m.setConstant(kTRUE);
n.setVal(1.6141); if (systString == "Resummation" || systString == "TopMass") n.setConstant(kTRUE);
n2.setVal(1.3294); n2.setConstant(kTRUE);
bb.setVal(4.2761); // bb.setConstant(kTRUE);
T.setVal(0.0361); // T.setConstant(kTRUE);
bb2.setVal(1.6643); bb2.setConstant(kTRUE);
fexp.setVal(0.0004); // fexp.setConstant(kTRUE);
}
} else if (whichtype == 1) {
m.setVal(1.006); // m.setConstant(kTRUE);
n.setVal(10.939); n.setConstant(kTRUE);
n2.setVal(1.1448); n2.setConstant(kTRUE);
bb.setVal(0.02048); bb.setConstant(kTRUE);
T.setVal(0.16115); if (systString.find("Mela") != string::npos) T.setConstant(kTRUE); // T.setConstant(kTRUE);
bb2.setVal(1.0024); bb2.setConstant(kTRUE);
fexp.setVal(0.005); fexp.setConstant(kTRUE);
if (mass > 300) {
fexp.setVal(0.0); fexp.setConstant(kFALSE);
}
if (mass > 500) {
bb2.setVal(5.0); // bb2.setConstant(kFALSE);
}
if (mass > 500) {
bb.setVal(15.0); // bb.setConstant(kFALSE);
}
} else if (whichtype == 2) {
if (LHCsqrts == 8) {
m.setVal(1.0476); // m.setConstant(kTRUE);
bb.setVal(3.3088); // if (mass != 140) bb.setConstant(kTRUE);
n2.setVal(0.7146); n2.setConstant(kTRUE);
n.setVal(0.9518); n.setConstant(kTRUE);
bb2.setVal(100000.); bb2.setConstant(kTRUE);
T.setVal(0.0021889); if (systString.find("Mela") != string::npos || mass != 140) T.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
} else {
m.setVal(1.028); // m.setConstant(kTRUE);
bb.setVal(2.91); // bb.setConstant(kTRUE);
n2.setVal(0.7146); n2.setConstant(kTRUE);
n.setVal(0.9518); n.setConstant(kTRUE);
bb2.setVal(100000.); bb2.setConstant(kTRUE);
T.setVal(0.002248); if (systString.find("Mela") != string::npos) T.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
}
} else if (whichtype == 3) {
m.setVal(1.411); // m.setConstant(kTRUE);
n.setVal(3.4523); n.setConstant(kTRUE);
n2.setVal(0.6910); n2.setConstant(kTRUE);
bb.setVal(0.00039); // bb.setConstant(kTRUE);
T.setVal(0.118); // T.setConstant(kTRUE);
bb2.setVal(0.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
} else if (whichtype == 4) {
m.setVal(1.411); // m.setConstant(kTRUE);
n.setVal(5.756); // n.setConstant(kTRUE);
n2.setVal(0.8738); // n2.setConstant(kTRUE);
bb.setVal(0.00039); // bb.setConstant(kTRUE);
T.setVal(0.118); // T.setConstant(kTRUE);
bb2.setVal(0.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
} else if (whichtype == 5 && LHCsqrts == 8) {
m.setVal(1.006); // m.setConstant(kTRUE);
n.setVal(10.939); n.setConstant(kTRUE);
n2.setVal(1.1448); n2.setConstant(kTRUE);
bb.setVal(3.897); bb.setConstant(kTRUE);
T.setVal(0.1009); // T.setConstant(kTRUE);
bb2.setVal(1.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.01); fexp.setConstant(kTRUE);
} else {
// cout << "Entro qui" << endl;
m.setVal(1.006); // m.setConstant(kTRUE);
n.setVal(10.939); n.setConstant(kTRUE);
n2.setVal(1.1448); n2.setConstant(kTRUE);
bb.setVal(0.0129); bb.setConstant(kTRUE);
T.setVal(0.1009); // T.setConstant(kTRUE);
bb2.setVal(1.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.01); fexp.setConstant(kTRUE);
}
RooModifTsallis* rt3 = new RooModifTsallis("rt3","rt3",*ptoverm,m,n,n2,bb,bb2,T,fexp);
// ws->import(*rt3);
// fit
RooFitResult* fit = rt3->fitTo(*rdh,Minos(0),Save(1),SumW2Error(kTRUE),NumCPU(1));
float mVal = m.getVal();
float nVal = n.getVal();
float n2Val = n2.getVal();
float bbVal = bb.getVal();
float bb2Val = bb2.getVal();
float fexpVal = fexp.getVal();
float TVal = T.getVal();
if (correctErrors) {
// Tsallis errors not reliable, use toy MC
TH1F* mHist = new TH1F("mHist","m",21,-0.5*mVal,0.5*mVal);
TH1F* nHist = new TH1F("nHist","n",21,-0.2*nVal,0.2*nVal);
TH1F* n2Hist = new TH1F("n2Hist","n2",21,-0.2*n2Val,0.2*n2Val);
TH1F* bbHist = new TH1F("bbHist","bb",21,-0.2*bbVal,0.2*bbVal);
TH1F* bb2Hist = new TH1F("bb2Hist","bb2",21,-0.2*bb2Val,0.2*bb2Val);
TH1F* fexpHist = new TH1F("fexpHist","fexp",21,-0.2*fexpVal-0.000001,0.2*fexpVal+0.000001);
TH1F* THist = new TH1F("THist","T",21,-0.5*TVal,0.5*TVal);
mHist->GetXaxis()->SetTitle("m-m_{gen}");
nHist->GetXaxis()->SetTitle("n-n_{gen}");
n2Hist->GetXaxis()->SetTitle("n2-n2_{gen}");
bbHist->GetXaxis()->SetTitle("bb-bb_{gen}");
bb2Hist->GetXaxis()->SetTitle("bb2-bb2_{gen}");
THist->GetXaxis()->SetTitle("T-T_{gen}");
fexpHist->GetXaxis()->SetTitle("fexp-fexp_{gen}");
for (unsigned int iToy = 0; iToy < 200; iToy++) {
cout << endl << "####" << endl;
cout << "Generating toy experiment n. " << iToy+1 << endl;
m.setVal(mVal);
n.setVal(nVal);
n2.setVal(n2Val);
bb.setVal(bbVal);
bb2.setVal(bb2Val);
fexp.setVal(fexpVal);
T.setVal(TVal);
TDatime *now = new TDatime();
Int_t seed = now->GetDate() + now->GetTime();
cout << "RooFit Generation Seed = " << seed+iToy << endl;
RooRandom::randomGenerator()->SetSeed(seed+iToy);
cout << "####" << endl << endl;
RooDataSet *dataToy = rt3->generate(RooArgSet(*ptoverm),ptovermH->GetEntries());
RooDataHist *dataToyH = new RooDataHist("dataToyH","toy",RooArgSet(*ptoverm),*dataToy);
rt3->fitTo(*dataToyH,Minos(0),SumW2Error(kTRUE),NumCPU(1));
if (fit->floatParsFinal().find("m")) mHist->Fill(m.getVal()-mVal);
if (fit->floatParsFinal().find("n")) nHist->Fill(n.getVal()-nVal);
if (fit->floatParsFinal().find("n2")) n2Hist->Fill(n2.getVal()-n2Val);
if (fit->floatParsFinal().find("bb")) bbHist->Fill(bb.getVal()-bbVal);
if (fit->floatParsFinal().find("bb2")) bb2Hist->Fill(bb2.getVal()-bb2Val);
if (fit->floatParsFinal().find("fexp")) fexpHist->Fill(fexp.getVal()-fexpVal);
if (fit->floatParsFinal().find("T")) THist->Fill(T.getVal()-TVal);
}
TCanvas cant("cant","Test canvas",5.,5.,900.,500.);
cant.Divide(4,2);
cant.cd(1); mHist->Draw();
cant.cd(2); nHist->Draw();
cant.cd(3); n2Hist->Draw();
cant.cd(4); bbHist->Draw();
cant.cd(5); bb2Hist->Draw();
cant.cd(6); fexpHist->Draw();
cant.cd(7); THist->Draw();
// cant.SaveAs("figs/testToys.pdf");
cant.SaveAs("newfigs/testToys.pdf");
if (fit->floatParsFinal().find("m")) m.setError(mHist->GetRMS());
if (fit->floatParsFinal().find("n")) n.setError(nHist->GetRMS());
if (fit->floatParsFinal().find("n2")) n2.setError(n2Hist->GetRMS());
if (fit->floatParsFinal().find("bb")) bb.setError(bbHist->GetRMS());
if (fit->floatParsFinal().find("bb2")) bb2.setError(bb2Hist->GetRMS());
if (fit->floatParsFinal().find("fexp")) fexp.setError(fexpHist->GetRMS());
if (fit->floatParsFinal().find("T")) T.setError(THist->GetRMS());
}
m.setVal(mVal);
n.setVal(nVal);
n2.setVal(n2Val);
bb.setVal(bbVal);
bb2.setVal(bb2Val);
fexp.setVal(fexpVal);
T.setVal(TVal);
char fileToSave[200];
// if (changeParName != "")
// sprintf(fileToSave,"text/paramsPTOverMCJLST_%s_%dTeV_%s_%s.txt",nameSample[whichtype].c_str(),LHCsqrts,systString.c_str(),changeParName.c_str());
// else
sprintf(fileToSave,"text/paramsPTOverMCJLST_%s%d_%dTeV_%s.txt",nameSample[whichtype].c_str(),mass,LHCsqrts,systString.c_str());
ofstream os1(fileToSave);
if (changeParName != "") {
sprintf(fileToSave,"m%s",changeParName.c_str()); m.SetName(fileToSave);
sprintf(fileToSave,"n%s",changeParName.c_str()); n.SetName(fileToSave);
sprintf(fileToSave,"n2%s",changeParName.c_str()); n2.SetName(fileToSave);
sprintf(fileToSave,"bb%s",changeParName.c_str()); bb.SetName(fileToSave);
sprintf(fileToSave,"bb2%s",changeParName.c_str()); bb2.SetName(fileToSave);
sprintf(fileToSave,"fexp%s",changeParName.c_str()); fexp.SetName(fileToSave);
sprintf(fileToSave,"T%s",changeParName.c_str()); T.SetName(fileToSave);
}
(RooArgSet(m,n,n2,bb,bb2,fexp,T)).writeToStream(os1,false);
os1.close();
RooRealVar mup("mup","emme", 1.,0.01, 30.);
RooRealVar nup("nup","enne", 0.93, 0.5, 15.);
RooRealVar n2up("n2up","enne2", 0.75, 0.5, 15.);
RooRealVar bbup("bbup","bibi",0.02, 0.00005, 20.0);
RooRealVar Tup("Tup","tti",0.2,0.00000005,1.);
RooRealVar bb2up("bb2up","bibi2",0.02, 0.0005, 10.0);
RooRealVar fexpup("fexpup","f_exp",0.02, 0.0, 1.0);
RooModifTsallis* rt3up = new RooModifTsallis("rt3up","rt3up",*ptoverm,mup,nup,n2up,bbup,bb2up,Tup,fexpup);
// ws->import(*rt3up);
RooRealVar mdown("mdown","emme", 1.,0.01, 30.);
RooRealVar ndown("ndown","enne", 0.93, 0.5, 15.);
RooRealVar n2down("n2down","enne2", 0.75, 0.5, 15.);
RooRealVar bbdown("bbdown","bibi",0.02, 0.00005, 20.0);
RooRealVar Tdown("Tdown","tti",0.2,0.00000005,1.);
RooRealVar bb2down("bb2down","bibi2",0.02, 0.0005, 10.0);
RooRealVar fexpdown("fexpdown","f_exp",0.02, 0.0, 1.0);
RooModifTsallis* rt3down = new RooModifTsallis("rt3down","rt3down",*ptoverm,mdown,ndown,n2down,bbdown,bb2down,Tdown,fexpdown);
// ws->import(*rt3down);
RooPlot *frame = ptoverm->frame();
char reducestr[300];
sprintf(reducestr,"ptoverm > %f && ptoverm < %f",ptoverm->getMin(),ptoverm->getMax());
rdh->plotOn(frame,DataError(RooAbsData::SumW2),Cut(reducestr));
static RooHist *hpull;
float chi2 = 0.;
if (changeParName == "") {
sprintf(fileToSave,"text/paramsPTOverMCJLST_%s%d_%dTeV_Default.txt",nameSample[whichtype].c_str(),mass,LHCsqrts);
ifstream is1(fileToSave);
(RooArgSet(mup,nup,n2up,bbup,bb2up,fexpup,Tup)).readFromStream(is1,false);
mdown.setVal(fabs(3*mup.getVal() - 2*m.getVal()));
ndown.setVal(fabs(3*nup.getVal() - 2*n.getVal()));
n2down.setVal(fabs(3*n2up.getVal() - 2*n2.getVal()));
bbdown.setVal(fabs(3*bbup.getVal() - 2*bb.getVal()));
Tdown.setVal(fabs(3*Tup.getVal() - 2*T.getVal()));
bb2down.setVal(fabs(3*bb2up.getVal() - 2*bb2.getVal()));
fexpdown.setVal(fabs(3*fexpup.getVal() - 2*fexp.getVal()));
if (showErrorPDFs) {
rt3->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
hpull = frame->pullHist();
rt3up->plotOn(frame,LineColor(kBlue),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
if (systString.find("Mela") == string::npos) rt3down->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
} else {
rt3->plotOn(frame,LineColor(kBlue),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
hpull = frame->pullHist();
}
} else {
mup.setVal(m.getVal() + m.getError()); cout << "mup = " << mup.getVal() << endl;
nup.setVal(n.getVal() + n.getError());
n2up.setVal(n2.getVal() + n2.getError());
bbup.setVal(bb.getVal() + bb.getError());
Tup.setVal(T.getVal() + T.getError());
bb2up.setVal(bb2.getVal() + bb2.getError());
fexpup.setVal(fexp.getVal() + fexp.getError());
mdown.setVal(m.getVal() - m.getError()); cout << "mdown = " << mdown.getVal() << endl;
ndown.setVal(n.getVal() - n.getError());
n2down.setVal(n2.getVal() - n2.getError());
bbdown.setVal(bb.getVal() - bb.getError());
Tdown.setVal(T.getVal() - T.getError());
bb2down.setVal(bb2.getVal() - bb2.getError());
fexpdown.setVal(fexp.getVal() - fexp.getError());
rt3->plotOn(frame,LineColor(kBlue),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
hpull = frame->pullHist();
if (showErrorPDFs) {
rt3up->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
rt3down->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
}
}
double *ypulls = hpull->GetY();
unsigned int nBins = rdh->numEntries();
unsigned int nFullBins = 0;
for (unsigned int i = 0; i < nBins; i++) {
cout << "Pull of bin " << i << " = " << ypulls[i] << endl;
if (fabs(ypulls[i]) < 5.0) chi2 += ypulls[i]*ypulls[i];
cout << "Partial chi2 = " << chi2 << endl;
if (fabs(ypulls[i]) > 0.0001 && fabs(ypulls[i]) < 5.0) nFullBins++;
}
for (unsigned int i = 0; i < nBins; i++) {
if (fabs(ypulls[i]) < 0.0001) ypulls[i] = 999.;
hpull->SetPointError(i,0.,0.,0.,0.);
}
int nFitPar = fit->floatParsFinal().getSize() - 1;
TCanvas can("can","The canvas",5.,5.,500.,900.);
can.Divide(1,3);
TLatex *t = new TLatex();
t->SetNDC();
t->SetTextAlign(22);
t->SetTextSize(0.06);
can.cd(1);
gPad->SetBottomMargin(0.0);
frame->Draw();
// gPad->SetLogy();
// Htest->Draw();
sprintf(fileToSave,"%s %d GeV at %d TeV",nameSample[whichtype].c_str(),mass,LHCsqrts);
t->DrawLatex(0.6,0.8,fileToSave);
can.cd(2);
gPad->SetLogy();
gPad->SetTopMargin(0.0);
frame->Draw();
RooPlot* pull = ptoverm->frame(Title("Pull Distribution")) ;
pull->GetYaxis()->SetTitle("Pull");
/* pull->SetLabelSize(0.08,"XYZ");
pull->SetTitleSize(0.08,"XYZ");
pull->SetTitleOffset(0.6,"Y");
pull->SetTitleOffset(1.0,"X"); */
pull->addPlotable(hpull,"P") ;
pull->SetMinimum(-6.);
pull->SetMaximum(6.);
can.cd(3);
gPad->SetGridy();
pull->Draw();
sprintf(fileToSave,"#chi^{2}/n_{DoF} = %4.1f/%d",chi2,nFullBins - nFitPar);
if (chi2 < 1000.) t->DrawLatex(0.80,0.86,fileToSave);
// sprintf(fileToSave,"figs/fitPTOverMCJLST_%s%d_%dTeV_%s.pdf",nameSample[whichtype].c_str(),mass,LHCsqrts,systString.c_str());
sprintf(fileToSave,"newfigs/fitPTOverMCJLST_%s%d_%dTeV_%s.pdf",nameSample[whichtype].c_str(),mass,LHCsqrts,systString.c_str());
can.SaveAs(fileToSave);
}
vector<float*> simFit(
const string tnp_ = "elecTnP",
const string category_ = "elecID80",
double cutValue_ = 0.5,
const string bin_ = "abseta>1.5",
const float binCenter_ = 0.75,
const float binWidth_ = 0.75,
const float xLow_ = 40,
const float xHigh_ = 120,
const float nBins_ = 24,
bool doBinned_ = true,
float deltaAlpha_ = 0.0,
float deltaN_ = 0.0,
float scale_ = 0.0
)
{
vector<float*> out;
TFile fSgn("../prod/ElecTnP/treeElecTnP_DYJets-50-madgraph-PUS4-TnP.root");
TTree *fullTreeSgn = (TTree*)fSgn.Get((tnp_+"/fitter_tree").c_str());
fSgn.cd("allEventsFilter");
TH1F* totalEventsSgn = (TH1F*)gDirectory->Get("totalEvents");
float readEventsSgn = totalEventsSgn->GetBinContent(1);
// data
TFile fdat("../prod/ElecTnP/treeElecTnP_DYJets-50-madgraph-PUS4-TnP.root");
TTree *fullTreeData = (TTree*)fdat.Get((tnp_+"/fitter_tree").c_str());
TH1F* hS = new TH1F("hS","",1,0,150);
TH1F* hSP = new TH1F("hSP","",1,0,150);
fullTreeSgn->Draw("mass>>hS",Form("tag_puMCWeight*(%s && mass>%f && mass<%f && mcTrue && tag_genDecay==23*11 && tag_pfRelIso<0.1 && pair_tnpCharge==0 && event_met_pfmet<25 && tag_pt>35)",bin_.c_str(),xLow_,xHigh_));
float SGNtrue = hS->Integral();
fullTreeSgn->Draw("mass>>hSP",Form("tag_puMCWeight*(%s && %s>=%f && mass>%f && mass<%f && mcTrue && tag_genDecay==23*11 && tag_pfRelIso<0.1 && pair_tnpCharge==0 && event_met_pfmet<25 && tag_pt>35)",bin_.c_str(),category_.c_str(),cutValue_,xLow_,xHigh_));
float SGNtruePass = hSP->Integral();
float McTruthEff = SGNtruePass/SGNtrue;
float BinomialError = TMath::Sqrt(SGNtruePass/SGNtrue*(1-SGNtruePass/SGNtrue)/SGNtrue);
cout << bin_.c_str() << " ==> MCTRUTH: " << McTruthEff << " +/- " << BinomialError << endl;
delete hS; delete hSP;
// file to copy the trees
TFile *templFile = new TFile(Form("dummyTempl_bin%.2f.root",binCenter_),"RECREATE");
TTree* fullTreeSgnCutP = fullTreeSgn->CopyTree( Form("(%s>=%f && %s && pair_tnpCharge==0 && event_met_pfmet<25 && mcTrue && tag_genDecay==23*11 && tag_pfRelIso<0.1 && tag_pt>35)",category_.c_str(),cutValue_,bin_.c_str()) );
TTree* fullTreeSgnCutF = fullTreeSgn->CopyTree( Form("(%s< %f && %s && pair_tnpCharge==0 && event_met_pfmet<25 && mcTrue && tag_genDecay==23*11 && tag_pfRelIso<0.1 && tag_pt>35)",category_.c_str(),cutValue_,bin_.c_str()) );
RooRealVar mass("mass","m_{tp} (GeV/c^{2})",xLow_,xHigh_);
mass.setBins( 10000, "fft" );
mass.setBins( nBins_ );
RooRealVar meanBkgP("meanBkgP","",59,30,100);
RooRealVar sigmaBkgP("sigmaBkgP","",11,0,50);
//RooLandau bkgPdfP("bkgPdfP","",mass,meanBkgP,sigmaBkgP);
RooRealVar DataCP("DataCP","",0);
RooExponential bkgPdfP("bkgPdfP","",mass,DataCP);
RooRealVar meanBkgF("meanBkgF","",59,30,100);
RooRealVar sigmaBkgF("sigmaBkgF","",11,0,50);
//RooLandau bkgPdfF("bkgPdfF","",mass,meanBkgF,sigmaBkgF);
RooRealVar DataCF("DataCF","",0,-10,10);
RooExponential bkgPdfF("bkgPdfF","",mass,DataCF);
TCanvas *c0 = new TCanvas("fitCanvas","canvas",10,30,650,600);
c0->SetGrid(0,0);
c0->SetFillStyle(4000);
c0->SetFillColor(10);
c0->SetTicky();
c0->SetObjectStat(0);
mass.setBins( 50 );
/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
// passing:
RooDataSet sgnDataSetP("sgnDataSetP","dataset for signal", RooArgSet(mass), Import( *fullTreeSgnCutP ) );
RooDataHist sgnDataHistP("sgnDataHistP","",RooArgSet(mass),sgnDataSetP, 1.0);
//RooHistPdf sgnTemplatePdfP("sgnTemplatePdfP","",RooArgSet(mass),sgnDataHistP);
RooKeysPdf sgnTemplatePdfP("sgnTemplatePdfP","",mass,sgnDataSetP);
// Breit-Wigner
RooRealVar meanSgnP("meanSgnP","mean",91.19,85,100);
RooRealVar widthSgnP("widthSgnP","width",2.49,0.,10);
RooBreitWigner bwSgnP("bwSgnP","bw",mass,meanSgnP,widthSgnP);
// Crystall Ball
RooRealVar m1SgnP("m1SgnP","m1",0,-20,20);
RooRealVar sigmaSgnP("sigmaSgnP","sigma",0.5,0,20);
RooRealVar alfaSgnP("alfaSgnP","alfa", 0.5,-10,10);
RooRealVar nSgnP("nSgnP","n", 1,1e-06,50);
RooCBShape cbSgnP("cbSgnP","",mass,m1SgnP,sigmaSgnP,alfaSgnP,nSgnP);
mass.setBins( 1000 , "fft");
// BW (X) CB
RooFFTConvPdf bvcbSgnP("bvcbSgnP","",mass,bwSgnP, cbSgnP);
RooFitResult* ResSgnFitP = bvcbSgnP.fitTo(sgnDataSetP, Minos(1), Save(1), NumCPU(4) );
RooArgSet FitParamSgnP(ResSgnFitP->floatParsFinal());
RooRealVar* m1SgnFitP = (RooRealVar*)(&FitParamSgnP["m1SgnP"]);
RooRealVar* sigmaSgnFitP = (RooRealVar*)(&FitParamSgnP["sigmaSgnP"]);
RooRealVar* alfaSgnFitP = (RooRealVar*)(&FitParamSgnP["alfaSgnP"]);
RooRealVar* nSgnFitP = (RooRealVar*)(&FitParamSgnP["nSgnP"]);
RooRealVar* nMeanSgnFitP = (RooRealVar*)(&FitParamSgnP["meanSgnP"]);
RooRealVar* nWidthSgnFitP= (RooRealVar*)(&FitParamSgnP["widthSgnP"]);
RooRealVar m1SgnP_C("m1SgnP_C","m1",m1SgnFitP->getVal(),-10,10);
RooRealVar sigmaSgnP_C("sigmaSgnP_C","sigma",sigmaSgnFitP->getVal(),0,20);
// choose to let it float or not
RooRealVar meanSgnP_C("meanSgnP_C","mean", nMeanSgnFitP->getVal() ,80,120);
RooRealVar widthSgnP_C("widthSgnP_C","width",nWidthSgnFitP->getVal() /*,0.,10*/);
RooRealVar alfaSgnP_C("alfaSgnP_C","alfa",alfaSgnFitP->getVal()*(1+deltaAlpha_)/*,0,20*/);
RooRealVar nSgnP_C("nSgnP_C","n",nSgnFitP->getVal()*(1+deltaN_)/*,0,50*/);
RooCBShape cbSgnP_C("cbSgnP_C","",mass,m1SgnP_C,sigmaSgnP_C,alfaSgnP_C,nSgnP_C);
RooLognormal alfaSgnP_CPdf("alfaSgnP_CPdf","",alfaSgnP_C,RooConst(alfaSgnFitP->getVal()),RooConst(1.5));
RooLognormal nSgnP_CPdf("nSgnP_CPdf","",nSgnP_C,RooConst(nSgnFitP->getVal()), RooConst(1.5));
RooLognormal meanSgnP_CPdf("meanSgnP_CPdf","",meanSgnP_C,RooConst(nMeanSgnFitP->getVal()),RooConst(1.5));
RooLognormal widthSgnP_CPdf("widthSgnP_CPdf","",widthSgnP_C,RooConst(nWidthSgnFitP->getVal()),RooConst(1.5));
// fitted BW (X) CB
RooBreitWigner bwSgnP_C("bwSgnP_C","bw",mass,meanSgnP_C,widthSgnP_C);
RooFFTConvPdf sgnPdfP("sgnPdfP","",mass,bwSgnP_C, cbSgnP_C);
RooRealVar sgnMeanResP("sgnMeanResP","",0,-10,10);
RooRealVar sgnSigmaResP("sgnSigmaResP","",0.5,0,10);
RooGaussian resolModP("sgnResolModP","",mass,sgnMeanResP,sgnSigmaResP);
mass.setBins(nBins_);
//return;
/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
// failing:
RooDataSet sgnDataSetF("sgnDataSetF","dataset for signal", RooArgSet(mass), Import( *fullTreeSgnCutF ) );
RooDataHist sgnDataHistF("sgnDataHistF","",RooArgSet(mass),sgnDataSetF, 1.0);
//RooHistPdf sgnTemplatePdfF("sgnTemplatePdfF","",RooArgSet(mass),sgnDataHistF);
RooKeysPdf sgnTemplatePdfF("sgnTemplatePdfF","",mass,sgnDataSetF);
// Breit-Wigner
RooRealVar meanSgnF("meanSgnF","mean",91.19,85,100);
RooRealVar widthSgnF("widthSgnF","width",2.49,0.,10);
RooBreitWigner bwSgnF("bwSgnF","bw",mass,meanSgnF,widthSgnF);
// Crystall Ball
RooRealVar m1SgnF("m1SgnF","m1",0,-20,20);
RooRealVar sigmaSgnF("sigmaSgnF","sigma",0.5,0,20);
RooRealVar alfaSgnF("alfaSgnF","alfa", 0.5,-10,10);
RooRealVar nSgnF("nSgnF","n", 1,1e-06,50);
RooCBShape cbSgnF("cbSgnF","",mass,m1SgnF,sigmaSgnF,alfaSgnF,nSgnF);
// BW (X) CB
RooFFTConvPdf bvcbSgnF("bvcbSgnF","",mass,bwSgnF, cbSgnF);
RooFitResult* ResSgnFitF = bvcbSgnF.fitTo(sgnDataSetF, Minos(1), Save(1), NumCPU(4) );
RooArgSet FitParamSgnF(ResSgnFitF->floatParsFinal());
RooRealVar* m1SgnFitF = (RooRealVar*)(&FitParamSgnF["m1SgnF"]);
RooRealVar* sigmaSgnFitF = (RooRealVar*)(&FitParamSgnF["sigmaSgnF"]);
RooRealVar* alfaSgnFitF = (RooRealVar*)(&FitParamSgnF["alfaSgnF"]);
RooRealVar* nSgnFitF = (RooRealVar*)(&FitParamSgnF["nSgnF"]);
RooRealVar* nMeanSgnFitF = (RooRealVar*)(&FitParamSgnF["meanSgnF"]);
RooRealVar* nWidthSgnFitF= (RooRealVar*)(&FitParamSgnF["widthSgnF"]);
RooRealVar m1SgnF_C("m1SgnF_C","m1",m1SgnFitF->getVal(),-10,10);
RooRealVar sigmaSgnF_C("sigmaSgnF_C","sigma",sigmaSgnFitF->getVal(),0,20);
// choose to let it float or not
RooRealVar meanSgnF_C("meanSgnF_C","mean", nMeanSgnFitF->getVal() ,80,120);
RooRealVar widthSgnF_C("widthSgnF_C","width",nWidthSgnFitF->getVal() /*,0.,10*/);
RooRealVar alfaSgnF_C("alfaSgnF_C","alfa",alfaSgnFitF->getVal()*(1+deltaAlpha_)/*,0,20*/);
RooRealVar nSgnF_C("nSgnF_C","n",nSgnFitF->getVal()*(1+deltaN_)/*,0,50*/);
RooCBShape cbSgnF_C("cbSgnF_C","",mass,m1SgnF_C,sigmaSgnF_C,alfaSgnF_C,nSgnF_C);
RooLognormal alfaSgnF_CPdf("alfaSgnF_CPdf","",alfaSgnF_C,RooConst(alfaSgnFitF->getVal()),RooConst(1.5));
RooLognormal nSgnF_CPdf("nSgnF_CPdf","",nSgnF_C,RooConst(nSgnFitF->getVal()), RooConst(1.5));
RooLognormal meanSgnF_CPdf("meanSgnF_CPdf","",meanSgnF_C,RooConst(nMeanSgnFitF->getVal()),RooConst(1.5));
RooLognormal widthSgnF_CPdf("widthSgnF_CPdf","",widthSgnF_C,RooConst(nWidthSgnFitF->getVal()),RooConst(1.5));
// fitted BW (X) CB
RooBreitWigner bwSgnF_C("bwSgnF_C","bw",mass,meanSgnF_C,widthSgnF_C);
RooFFTConvPdf sgnPdfF("sgnPdfF","",mass,bwSgnF_C, cbSgnF_C);
RooRealVar sgnMeanResF("sgnMeanResF","",0,-10,10);
RooRealVar sgnSigmaResF("sgnSigmaResF","",0.5,0,10);
RooGaussian resolModF("sgnResolModF","",mass,sgnMeanResF,sgnSigmaResF);
mass.setBins(nBins_);
//return;
// Fit
RooCategory category("category","category") ;
category.defineType("pass") ;
category.defineType("fail") ;
RooRealVar DataNumBkgF("DataNumBkgF","",0,10000000);
RooRealVar DataNumBkgP("DataNumBkgP","",0,10000000);
RooRealVar DataNumSgn("DataNumSgn","", 0,10000000);
RooRealVar DataEfficiency("DataEfficiency","",0.5,0,1);
RooFormulaVar DataNumSgnP("DataNumSgnP","DataEfficiency*DataNumSgn", RooArgSet(DataEfficiency,DataNumSgn));
RooFormulaVar DataNumSgnF("DataNumSgnF","(1-DataEfficiency)*DataNumSgn",RooArgSet(DataEfficiency,DataNumSgn));
RooAddPdf DataModelP("DataModelP","",RooArgList(sgnPdfP,bkgPdfP),RooArgList(DataNumSgnP,DataNumBkgP));
RooAddPdf DataModelF("DataModelF","",RooArgList(sgnPdfF,bkgPdfF),RooArgList(DataNumSgnF,DataNumBkgF));
TFile* dummyData = new TFile("dummyData.root","RECREATE");
TTree* fullTreeDataCutP = fullTreeData->CopyTree( Form("(%s>=%f && %s && tag_pfRelIso<0.1 && pair_tnpCharge==0 && event_met_pfmet<25 && (tag_hlt1==1 || tag_hlt2==1) && tag_pt>35)",category_.c_str(),cutValue_,bin_.c_str()) );
TTree* fullTreeDataCutF = fullTreeData->CopyTree( Form("(%s <%f && %s && tag_pfRelIso<0.1 && pair_tnpCharge==0 && event_met_pfmet<25 && (tag_hlt1==1 || tag_hlt2==1) && tag_pt>35)",category_.c_str(),cutValue_,bin_.c_str()) );
mass.setBins(nBins_);
RooDataSet DataDataSetP("DataDataSetP","dataset for Data pass", RooArgSet(mass), Import( *fullTreeDataCutP ) );
std::cout << "data dataset Pass " << DataDataSetP.numEntries() << " " << std::endl;
//return out;
RooDataHist DataDataHistP("DataDataHistP","",RooArgSet(mass),DataDataSetP, 1.0);
RooDataSet DataDataSetF("DataDataSetF","dataset for Data fail", RooArgSet(mass), Import( *fullTreeDataCutF ) );
std::cout << "data dataset Fail " << DataDataSetF.numEntries() << " " << std::endl;
RooDataHist DataDataHistF("DataDataHistF","",RooArgSet(mass),DataDataSetF, 1.0);
RooRealVar DataNumSgnP_("DataNumSgnP_","",0,10000);
RooAddPdf DataModelP_("DataModelP_","",RooArgList(sgnPdfP,bkgPdfP),RooArgList(DataNumSgnP_,DataNumBkgP));
DataModelP_.fitTo(DataDataSetP, Extended(1), Minos(1), Save(1), NumCPU(4),SumW2Error(1) /*,ExternalConstraints( RooArgSet(meanSgn_CPdf,widthSgn_CPdf) )*/);
RooPlot* frame2 = mass.frame(Title("template"));
DataDataSetP.plotOn(frame2);
DataModelP_.plotOn(frame2, LineColor(kBlue), LineStyle(kSolid));
DataModelP_.plotOn(frame2, Components("sgnPdfP"), LineColor(kRed), LineStyle(kSolid));
DataModelP_.plotOn(frame2, Components("bkgPdfP"), LineColor(kGreen), LineStyle(kSolid));
frame2->Draw();
//return;
// binned combined dataset
RooDataHist DataCombData("DataCombData","combined data",mass,Index(category),Import("pass", *(DataDataSetP.createHistogram("histoDataP",mass)) ) ,Import("fail", *(DataDataSetF.createHistogram("histoDataF",mass))), Weight(0.5) ) ;
std::cout << "data dataHist Comb " << DataCombData.sumEntries() << " " << std::endl;
std::cout << "+++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
// unbinned combined dataset
RooDataSet DataCombDataUnBinned("DataCombDataUnBinned","combined data",mass,Index(category),Import("pass", DataDataSetP ) ,Import("fail",DataDataSetF), Weight(0.5) ) ;
std::cout << "data dataset Comb " << DataCombDataUnBinned.numEntries() << " " << std::endl;
std::cout << "+++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
//return out;
RooSimultaneous DataSimPdf("DataSimPdf","simultaneous pdf",category) ;
DataSimPdf.addPdf(DataModelP,"pass") ;
DataSimPdf.addPdf(DataModelF,"fail") ;
//mass.setBins( 10000, "fft" );
mass.setBins( nBins_ );
RooFitResult* ResDataCombinedFit = 0;
if(doBinned_) ResDataCombinedFit = DataSimPdf.fitTo(DataCombData , Extended(1), Minos(1), Save(1), NumCPU(4), /*ExternalConstraints( RooArgSet(alfaSgn_CPdf,nSgn_CPdf) )*/ SumW2Error(1));
else ResDataCombinedFit = DataSimPdf.fitTo(DataCombDataUnBinned , Extended(1), Minos(1), Save(1), NumCPU(4), /*ExternalConstraints( RooArgSet(alfaSgn_CPdf,nSgn_CPdf) )*/ SumW2Error(1));
RooArgSet DataFitParam(ResDataCombinedFit->floatParsFinal());
RooRealVar* DataEffFit = (RooRealVar*)(&DataFitParam["DataEfficiency"]);
RooRealVar* DataNumSigFit = (RooRealVar*)(&DataFitParam["DataNumSgn"]);
RooPlot* DataFrameP = mass.frame(Bins(40),Title("CMS Preliminary 2011 #sqrt{s}=7 TeV L=XXX pb^{-1}: passing probe"));
DataCombData.plotOn(DataFrameP,Cut("category==category::pass"));
DataSimPdf.plotOn(DataFrameP,Slice(category,"pass"), ProjWData(category,DataCombData), LineColor(kBlue));
DataSimPdf.plotOn(DataFrameP,Slice(category,"pass"), ProjWData(category,DataCombData), Components("sgnPdfP"), LineColor(kRed), LineStyle(kSolid));
DataSimPdf.plotOn(DataFrameP,Slice(category,"pass"), ProjWData(category,DataCombData), Components("bkgPdfP"), LineColor(kMagenta), LineStyle(kDashed));
RooPlot* DataFrameF = mass.frame(Bins(40),Title("CMS Preliminary 2011 #sqrt{s}=7 TeV L=XXX pb^{-1}: failing probe"));
DataCombData.plotOn(DataFrameF,Cut("category==category::fail"));
DataSimPdf.plotOn(DataFrameF,Slice(category,"fail"), ProjWData(category,DataCombData), LineColor(kBlue));
DataSimPdf.plotOn(DataFrameF,Slice(category,"fail"), ProjWData(category,DataCombData), Components("sgnPdfF"), LineColor(kRed), LineStyle(kSolid));
DataSimPdf.plotOn(DataFrameF,Slice(category,"fail"), ProjWData(category,DataCombData), Components("bkgPdfF"), LineColor(kMagenta), LineStyle(kDashed));
TCanvas *cPass = new TCanvas("fitCanvasP","canvas",10,30,650,600);
cPass->SetGrid(0,0);
cPass->SetFillStyle(4000);
cPass->SetFillColor(10);
cPass->SetTicky();
cPass->SetObjectStat(0);
cPass->cd();
DataFrameP->Draw();
string fileNameP = "fitCanvasPassElecTnP_"+tnp_+"_"+category_;
cPass->SaveAs(Form("%s_%.2f.png",fileNameP.c_str(), binCenter_));
TCanvas *cFail = new TCanvas("fitCanvasF","canvas",10,30,650,600);
cFail->SetGrid(0,0);
cFail->SetFillStyle(4000);
cFail->SetFillColor(10);
cFail->SetTicky();
cFail->SetObjectStat(0);
cFail->cd();
DataFrameF->Draw();
string fileNameF = "fitCanvasFailElecTnP_"+tnp_+"_"+category_;
cFail->SaveAs(Form("%s_%.2f.png",fileNameF.c_str(), binCenter_));
ResDataCombinedFit->printArgs(std::cout);
cout << endl;
ResDataCombinedFit->printValue(std::cout);
cout << endl;
float DataErrorLo = DataEffFit->getErrorLo()<0 ? DataEffFit->getErrorLo() : (-1)*DataEffFit->getError();
float DataErrorHi = DataEffFit->getErrorHi()>0 ? DataEffFit->getErrorHi() : DataEffFit->getError();
cout << DataEffFit->getVal() << " +/- " << DataEffFit->getError() << " ( " << DataErrorLo << ", " << DataErrorHi << ")" << endl;
float* out1 = new float[6];
float* out2 = new float[6];
out1[0]=(binCenter_);
out1[1]=(binWidth_);
out1[2]=(binWidth_);
out1[3]=(McTruthEff);
out1[4]=(BinomialError);
out1[5]=(BinomialError);
out2[0]=(binCenter_);
out2[1]=(binWidth_);
out2[2]=(binWidth_);
out2[3]=(DataEffFit->getVal());
out2[4]=((-1)*DataErrorLo);
out2[5]=(DataErrorHi);
out.push_back(out1);
out.push_back(out2);
return out;
}
int main(){
RooFitResult f1 = getRes();
RooArgList final_std_list = f1.floatParsFinal();
Float_t a_std[14];
a_std[0] = ((RooAbsReal*)final_std_list.find("Kst2z1430_amp"))->getVal();
a_std[1] = ((RooAbsReal*)final_std_list.find("Kst2z1430_phase"))->getVal();
a_std[2] = ((RooAbsReal*)final_std_list.find("Kstm1430_amp"))->getVal();
a_std[3] = ((RooAbsReal*)final_std_list.find("Kstm1430_phase"))->getVal();
a_std[4] = ((RooAbsReal*)final_std_list.find("Kstminus_amp"))->getVal();
a_std[5] = ((RooAbsReal*)final_std_list.find("Kstminus_phase"))->getVal();
a_std[6] = ((RooAbsReal*)final_std_list.find("Kstz1430_amp"))->getVal();
a_std[7] = ((RooAbsReal*)final_std_list.find("Kstz1430_phase"))->getVal();
a_std[8] = ((RooAbsReal*)final_std_list.find("Kstzero_amp"))->getVal();
a_std[9] = ((RooAbsReal*)final_std_list.find("Kstzero_phase"))->getVal();
a_std[10] = ((RooAbsReal*)final_std_list.find("Rho1700_amp"))->getVal();
a_std[11] = ((RooAbsReal*)final_std_list.find("Rho1700_phase"))->getVal();
a_std[12] = ((RooAbsReal*)final_std_list.find("c1"))->getVal();
a_std[13] = ((RooAbsReal*)final_std_list.find("c2"))->getVal();
Float_t err_std[14];
err_std[0] = ((RooRealVar*)final_std_list.find("Kst2z1430_amp"))->getError();
err_std[1] = ((RooRealVar*)final_std_list.find("Kst2z1430_phase"))->getError();
err_std[2] = ((RooRealVar*)final_std_list.find("Kstm1430_amp"))->getError();
err_std[3] = ((RooRealVar*)final_std_list.find("Kstm1430_phase"))->getError();
err_std[4] = ((RooRealVar*)final_std_list.find("Kstminus_amp"))->getError();
err_std[5] = ((RooRealVar*)final_std_list.find("Kstminus_phase"))->getError();
err_std[6] = ((RooRealVar*)final_std_list.find("Kstz1430_amp"))->getError();
err_std[7] = ((RooRealVar*)final_std_list.find("Kstz1430_phase"))->getError();
err_std[8] = ((RooRealVar*)final_std_list.find("Kstzero_amp"))->getError();
err_std[9] = ((RooRealVar*)final_std_list.find("Kstzero_phase"))->getError();
err_std[10] = ((RooRealVar*)final_std_list.find("Rho1700_amp"))->getError();
err_std[11] = ((RooRealVar*)final_std_list.find("Rho1700_phase"))->getError();
err_std[12] = ((RooRealVar*)final_std_list.find("c1"))->getError();
err_std[13] = ((RooRealVar*)final_std_list.find("c2"))->getError();
Float_t stat_matrix[14][14];
Float_t TOT_matrix[14][14];
Float_t TOT_syst_matrix[14][14];
for(Int_t j=0;j<14;j++){
for(Int_t k=0;k<14;k++){
stat_matrix[j][k] = f1.correlation( *((RooAbsReal*)final_std_list.at(j)) , *((RooAbsReal*)final_std_list.at(k)) )*err_std[j]*err_std[k];
TOT_matrix[j][k] = stat_matrix[j][k];
TOT_syst_matrix[j][k] = 0.;
}
}
/*
TFile f("toynomix_theRes.root");
RooFitResult *toyres = (RooFitResult*)f.Get("nll");
RooArgList toy_std_list = toyres->floatParsFinal();
Float_t toy_std[14];
toy_std[0] = ((RooAbsReal*)toy_std_list.find("Kst2z1430_amp"))->getVal();
toy_std[1] = ((RooAbsReal*)toy_std_list.find("Kst2z1430_phase"))->getVal();
toy_std[2] = ((RooAbsReal*)toy_std_list.find("Kstm1430_amp"))->getVal();
toy_std[3] = ((RooAbsReal*)toy_std_list.find("Kstm1430_phase"))->getVal();
toy_std[4] = ((RooAbsReal*)toy_std_list.find("Kstminus_amp"))->getVal();
toy_std[5] = ((RooAbsReal*)toy_std_list.find("Kstminus_phase"))->getVal();
toy_std[6] = ((RooAbsReal*)toy_std_list.find("Kstz1430_amp"))->getVal();
toy_std[7] = ((RooAbsReal*)toy_std_list.find("Kstz1430_phase"))->getVal();
toy_std[8] = ((RooAbsReal*)toy_std_list.find("Kstzero_amp"))->getVal();
toy_std[9] = ((RooAbsReal*)toy_std_list.find("Kstzero_phase"))->getVal();
toy_std[10] = ((RooAbsReal*)toy_std_list.find("Rho1700_amp"))->getVal();
toy_std[11] = ((RooAbsReal*)toy_std_list.find("Rho1700_phase"))->getVal();
toy_std[12] = ((RooAbsReal*)toy_std_list.find("c1"))->getVal();
toy_std[13] = ((RooAbsReal*)toy_std_list.find("c2"))->getVal();
Float_t err_toy_std[14];
err_toy_std[0] = ((RooRealVar*)toy_std_list.find("Kst2z1430_amp"))->getError();
err_toy_std[1] = ((RooRealVar*)toy_std_list.find("Kst2z1430_phase"))->getError();
err_toy_std[2] = ((RooRealVar*)toy_std_list.find("Kstm1430_amp"))->getError();
err_toy_std[3] = ((RooRealVar*)toy_std_list.find("Kstm1430_phase"))->getError();
err_toy_std[4] = ((RooRealVar*)toy_std_list.find("Kstminus_amp"))->getError();
err_toy_std[5] = ((RooRealVar*)toy_std_list.find("Kstminus_phase"))->getError();
err_toy_std[6] = ((RooRealVar*)toy_std_list.find("Kstz1430_amp"))->getError();
err_toy_std[7] = ((RooRealVar*)toy_std_list.find("Kstz1430_phase"))->getError();
err_toy_std[8] = ((RooRealVar*)toy_std_list.find("Kstzero_amp"))->getError();
err_toy_std[9] = ((RooRealVar*)toy_std_list.find("Kstzero_phase"))->getError();
err_toy_std[10] = ((RooRealVar*)toy_std_list.find("Rho1700_amp"))->getError();
err_toy_std[11] = ((RooRealVar*)toy_std_list.find("Rho1700_phase"))->getError();
err_toy_std[12] = ((RooRealVar*)toy_std_list.find("c1"))->getError();
err_toy_std[13] = ((RooRealVar*)toy_std_list.find("c2"))->getError();
Float_t stat_toy_matrix[14][14];
for(Int_t j=0;j<14;j++){
for(Int_t k=0;k<14;k++){
stat_toy_matrix[j][k] = toyres->correlation( *((RooAbsReal*)toy_std_list.at(j)) , *((RooAbsReal*)toy_std_list.at(k)) )*err_toy_std[j]*err_toy_std[k];
}
}
*/
//create the systematics matrx, the last element is the number of systematics scenarios
Float_t sys_matrix[14][14][TOT_syst];
Int_t index = 0;
//loop over all the systematics and fill the matrix
for(Int_t i=0;i<numsyst;i++){
if(i < first_alone && i % 2 != 0) continue;
RooFitResult fsyst = getRes(i);
RooArgList final_syst_list = fsyst.floatParsFinal();
Float_t a_syst[14];
Float_t a_syst_plus[14];
a_syst[0] = ((RooAbsReal*)final_syst_list.find("Kst2z1430_amp"))->getVal();
a_syst[1] = ((RooAbsReal*)final_syst_list.find("Kst2z1430_phase"))->getVal();
if(i != slot_LASS){
a_syst[2] = ((RooAbsReal*)final_syst_list.find("Kstm1430_amp"))->getVal();
a_syst[3] = ((RooAbsReal*)final_syst_list.find("Kstm1430_phase"))->getVal();
a_syst[6] = ((RooAbsReal*)final_syst_list.find("Kstz1430_amp"))->getVal();
a_syst[7] = ((RooAbsReal*)final_syst_list.find("Kstz1430_phase"))->getVal();
}
else{
a_syst[2] = a_std[2];
a_syst[3] = a_std[3];
a_syst[6] = a_std[6];
a_syst[7] = a_std[7];
}
a_syst[4] = ((RooAbsReal*)final_syst_list.find("Kstminus_amp"))->getVal();
a_syst[5] = ((RooAbsReal*)final_syst_list.find("Kstminus_phase"))->getVal();
a_syst[8] = ((RooAbsReal*)final_syst_list.find("Kstzero_amp"))->getVal();
a_syst[9] = ((RooAbsReal*)final_syst_list.find("Kstzero_phase"))->getVal();
if(i != slot_rho){
a_syst[10] = ((RooAbsReal*)final_syst_list.find("Rho1700_amp"))->getVal();
a_syst[11] = ((RooAbsReal*)final_syst_list.find("Rho1700_phase"))->getVal();
}
else{
a_syst[10] = a_std[10];
a_syst[11] = a_std[11];
}
a_syst[12] = ((RooAbsReal*)final_syst_list.find("c1"))->getVal();
a_syst[13] = ((RooAbsReal*)final_syst_list.find("c2"))->getVal();
if(i<first_alone){
RooFitResult fsyst_plus = getRes(i+1);
RooArgList final_syst_plus_list = fsyst_plus.floatParsFinal();
a_syst_plus[0] = ((RooAbsReal*)final_syst_plus_list.find("Kst2z1430_amp"))->getVal();
a_syst_plus[1] = ((RooAbsReal*)final_syst_plus_list.find("Kst2z1430_phase"))->getVal();
a_syst_plus[2] = ((RooAbsReal*)final_syst_plus_list.find("Kstm1430_amp"))->getVal();
a_syst_plus[3] = ((RooAbsReal*)final_syst_plus_list.find("Kstm1430_phase"))->getVal();
a_syst_plus[6] = ((RooAbsReal*)final_syst_plus_list.find("Kstz1430_amp"))->getVal();
a_syst_plus[7] = ((RooAbsReal*)final_syst_plus_list.find("Kstz1430_phase"))->getVal();
a_syst_plus[4] = ((RooAbsReal*)final_syst_plus_list.find("Kstminus_amp"))->getVal();
a_syst_plus[5] = ((RooAbsReal*)final_syst_plus_list.find("Kstminus_phase"))->getVal();
a_syst_plus[8] = ((RooAbsReal*)final_syst_plus_list.find("Kstzero_amp"))->getVal();
a_syst_plus[9] = ((RooAbsReal*)final_syst_plus_list.find("Kstzero_phase"))->getVal();
a_syst_plus[10] = ((RooAbsReal*)final_syst_plus_list.find("Rho1700_amp"))->getVal();
a_syst_plus[11] = ((RooAbsReal*)final_syst_plus_list.find("Rho1700_phase"))->getVal();
a_syst_plus[12] = ((RooAbsReal*)final_syst_plus_list.find("c1"))->getVal();
a_syst_plus[13] = ((RooAbsReal*)final_syst_plus_list.find("c2"))->getVal();
}
for(Int_t l=0;l<14;l++){
for(Int_t m=0;m<14;m++){
if(i<first_alone){
sys_matrix[l][m][index] = (a_syst[l] - a_std[l])*(a_syst[m] - a_std[m])/2. + (a_syst_plus[l] - a_std[l])*( a_syst_plus[m] - a_std[m])/2.;
TOT_matrix[l][m] += sys_matrix[l][m][index];
TOT_syst_matrix[l][m] += sys_matrix[l][m][index];
}
else{
sys_matrix[l][m][index] = (a_syst[l]-a_std[l])*(a_syst[m]-a_std[m]);
TOT_matrix[l][m] += sys_matrix[l][m][index];
TOT_syst_matrix[l][m] += sys_matrix[l][m][index];
}
}
}
index++;
} //end of loop over the systematics
//for(Int_t l=0;l<14;l++){
// cov_matrix[l][l] += 0.03*0.03*err_std[l]*err_std[l];
//}
//statistical covariance matrix
makeStatMatrix(stat_matrix);
//systematics covariance matrix
makeStatMatrix(TOT_syst_matrix);
//total covariance matrix
makeStatMatrix(TOT_matrix);
//summary table of all systematics contributions
makeTable(sys_matrix,err_std);
//summary of the sum of all systematics
makeTable_TOT(TOT_syst_matrix,err_std);
//write for toy generation
writeMatrix(stat_matrix,TOT_matrix);
make_part(sys_matrix,err_std);
return 0;
}
void toyMC(
int collId = kAADATA,
float ptLow=0, float ptHigh=5,
float yLow=0, float yHigh=2.4,
int cLow=0, int cHigh=200,
float muPtCut=4.0,
int inputOption=kChPol4, //kChPol3,
int nGen = 10000,
int useCentIntBkgShape = 1,
int nToys = 1000
)
{
using namespace RooFit;
RooRandom::randomGenerator()->SetSeed(111);
gStyle->SetEndErrorSize(0);
float Val_2S_1S_nom = 0;
float Val_2S_1S_alt = 0;
float Dev_2S_1S = 0;
TString fcoll;
TString finput;
if(collId == kAADATA) fcoll = "AA";
else if(collId == kPPDATA) fcoll = "PP";
if(inputOption == 3) finput = "4th poly";
else if(inputOption == 4) finput = "Nominal+Exp";
TFile *wf = new TFile(Form("%s_fit_pt%.1f-%.1f_rap%.1f-%.1f_cent%d-%d_Gen%d_input%d_useCentBkg%d_nToys%d.root",fcoll.Data(),ptLow,ptHigh,yLow,yHigh,cLow,cHigh,nGen,inputOption,useCentIntBkgShape,nToys),"recreate");
TH1D *h1 = new TH1D("h1",Form("SR Nominal, %d toys, %d events, cent %d-%d;2S/1S nom;Counts",nToys,nGen,cLow,cHigh),100,0,1);
TH1D *h2 = new TH1D("h2",Form("SR %s, %d toys, %d events, cent %d-%d;2S/1S nom;Counts",finput.Data(),nToys,nGen,cLow,cHigh),100,0,1);
TH1D *h3 = new TH1D("h3","Deviation;2S/1S dev;Counts",1000,0,100);
//----****************--------for loop -----*******************-----------------
//----****************--------for loop -----*******************-----------------
//----****************--------for loop -----*******************-----------------
//----****************--------for loop -----*******************-----------------
//----****************--------for loop -----*******************-----------------
for(int i=0;i<nToys;i++){
float massLow = 8. ;
float massHigh = 14.;
int nMassBin = (massHigh-massLow)*10;
RooWorkspace *ws = new RooWorkspace("ws");
RooWorkspace *wsinp = new RooWorkspace("wsinp");
RooRealVar mass("mass","mass", massLow, massHigh);
ws->import(mass);
wsinp->import(mass);
mass.Print();
RooRealVar mRatio21("mRatio21","mRatio21",pdgMass.Y2S / pdgMass.Y1S );
RooRealVar mRatio31("mRatio31","mRatio31",pdgMass.Y3S / pdgMass.Y1S );
RooRealVar mean1s("m_{#Upsilon(1S)}","mean of the signal gaussian mass PDF",pdgMass.Y1S, pdgMass.Y1S -0.1, pdgMass.Y1S + 0.1 ) ;
PSet3SingleCB InitialSetUpsilons = getUpsilonPsets( collId, ptLow, ptHigh, yLow, yHigh, cLow, cHigh, muPtCut) ;
RooRealVar sigma1s_1("sigma1s_1","width/sigma of the signal gaussian mass PDF",0.05, 0.05, 0.14);
RooRealVar sigma2s_1("sigma2s_1","width/sigma of the signal gaussian mass PDF",0.05, 0.05, 0.14);
RooRealVar sigma1s_2("sigma1s_2","width/sigma of the signal gaussian mass PDF",0.05, 0.05, 0.14);
RooRealVar sigma2s_2("sigma2s_2","width/sigma of the signal gaussian mass PDF",0.05, 0.05, 0.14);
RooRealVar alpha1s_1("alpha1s_1","tail shift", 5. , 1.0, 9.8);
RooRealVar alpha2s_1("alpha2s_1","tail shift", 5. , 1.15, 9.2);
RooRealVar alpha1s_2("alpha1s_2","tail shift", 5. , 1.0, 9.2);
RooRealVar alpha2s_2("alpha2s_2","tail shift", 2.5, 1.10, 10.);
RooRealVar n1s_1("n1s_1","power order", 5. , 1.4, 10.);
RooRealVar n2s_1("n2s_1","power order", 6. , 1.1, 9.5);
RooRealVar n1s_2("n1s_2","power order", 5. , 1.4, 10.);
RooRealVar n2s_2("n2s_2","power order", 6. , 1.1, 9.5);
RooRealVar *f1S = new RooRealVar("f1S","1S CB fraction", InitialSetUpsilons.MCf, InitialSetUpsilons.MCf*0.9, InitialSetUpsilons.MCf*1.1);
f1S->setVal(InitialSetUpsilons.MCf); f1S->setConstant();
RooRealVar X1S("X1S","sigma fraction 1S 2nd CB", InitialSetUpsilons.MCX, InitialSetUpsilons.MCX*0.9, InitialSetUpsilons.MCX*1.1);
// Fix the parameters
n1s_1.setVal(InitialSetUpsilons.MCN); n1s_1.setConstant();
n1s_2.setVal(InitialSetUpsilons.MCN); n1s_2.setConstant();
n2s_1.setVal(InitialSetUpsilons.MCN); n2s_1.setConstant();
n2s_2.setVal(InitialSetUpsilons.MCN); n2s_2.setConstant();
alpha1s_1.setVal(InitialSetUpsilons.MCAlpha); alpha1s_1.setConstant();
alpha1s_2.setVal(InitialSetUpsilons.MCAlpha); alpha1s_2.setConstant();
alpha2s_1.setVal(InitialSetUpsilons.MCAlpha); alpha2s_1.setConstant();
alpha2s_2.setVal(InitialSetUpsilons.MCAlpha); alpha2s_2.setConstant();
sigma1s_1.setVal(InitialSetUpsilons.MCSigma1S); sigma1s_1.setConstant();
sigma1s_2.setVal(InitialSetUpsilons.MCSigma1S); sigma1s_2.setConstant();
sigma2s_1.setVal(InitialSetUpsilons.MCSigma1S * InitialSetUpsilons.MCX ); sigma2s_1.setConstant();
sigma2s_2.setVal(InitialSetUpsilons.MCSigma1S * InitialSetUpsilons.MCX ); sigma2s_2.setConstant();
mean1s.setVal(InitialSetUpsilons.bkg_mass_res); mean1s.setConstant();
RooFormulaVar mean2s("mean2s","m_{#Upsilon(1S)}*mRatio21", RooArgSet(mean1s,mRatio21) );
RooFormulaVar mean3s("mean3s","m_{#Upsilon(1S)}*mRatio31", RooArgSet(mean1s,mRatio31) );
RooCBShape* cb1s_1 = new RooCBShape("cball1s_1", "cystal Ball", mass, mean1s, sigma1s_1, alpha1s_1, n1s_1);
RooCBShape* cb2s_1 = new RooCBShape("cball2s_1", "cystal Ball", mass, mean2s, sigma2s_1, alpha2s_1, n2s_1);
RooCBShape* cb1s_2 = new RooCBShape("cball1s_2", "cystal Ball", mass, mean1s, sigma1s_2, alpha1s_2, n1s_2);
RooCBShape* cb2s_2 = new RooCBShape("cball2s_2", "cystal Ball", mass, mean2s, sigma2s_2, alpha2s_2, n2s_2);
RooAddPdf* cb1s = new RooAddPdf();
RooAddPdf* cb2s = new RooAddPdf();
cb1s = new RooAddPdf("cb1s","Signal 1S",RooArgList(*cb1s_1,*cb1s_2), RooArgList(*f1S) );
cb2s = new RooAddPdf("cb2s","Signal 2S",RooArgList(*cb2s_1,*cb2s_2), RooArgList(*f1S) );
// Input model
PSet3SingleCB bkgParm = getUpsilonPsets( collId, ptLow, ptHigh, yLow, yHigh, cLow, cHigh, muPtCut) ;
PSet3SingleCB bkgParmCentInt;
if ( !( (cLow==0) && (cHigh==200) ) && (collId==kAADATA) ) {
bkgParmCentInt = getUpsilonPsets( collId, ptLow, ptHigh, yLow, yHigh, 0, 200, muPtCut) ;
cout << " ok done " << endl;
}
// if ( inputOption == kErrExp )
RooRealVar err_mu1("#mu1","err_mu1", bkgParm.bkg_mu1 ) ;
RooRealVar err_sigma1("#sigma1","err_sigma1", bkgParm.bkg_sigma1);
RooRealVar m_decay1("#lambda1","m_decay1", bkgParm.bkg_lambda1);
RooRealVar err_mu2("#mu2","err_mu2", bkgParm.bkg_mu2 ) ;
RooRealVar err_sigma2("#sigma2","err_sigma2", bkgParm.bkg_sigma2);
RooRealVar m_decay2("#lambda2","m_decay2", bkgParm.bkg_lambda2);
float the_ch3_k1 = bkgParm.ch3_k1 ; float the_ch3_k2 = bkgParm.ch3_k2 ; float the_ch3_k3 = bkgParm.ch3_k3 ;
float the_ch4_k1 = bkgParm.ch4_k1 ; float the_ch4_k2 = bkgParm.ch4_k2 ; float the_ch4_k3 = bkgParm.ch4_k3 ; float the_ch4_k4 = bkgParm.ch4_k4 ;
float the_bkg4_mu = bkgParm.bkg4_mu ; float the_bkg4_sigma = bkgParm.bkg4_sigma;
float the_bkg4_lambda = bkgParm.bkg4_lambda ; float the_bkg4_lambda2 = bkgParm.bkg4_lambda2 ;
if ( !( (cLow==0) && (cHigh==200) ) && (collId==kAADATA) && useCentIntBkgShape ) {
the_ch3_k1 = bkgParmCentInt.ch3_k1 ; the_ch3_k2 = bkgParmCentInt.ch3_k2 ; the_ch3_k3 = bkgParmCentInt.ch3_k3 ;
the_ch4_k1 = bkgParmCentInt.ch4_k1 ; the_ch4_k2 = bkgParmCentInt.ch4_k2 ; the_ch4_k3 = bkgParmCentInt.ch4_k3 ; the_ch4_k4 = bkgParmCentInt.ch4_k4 ;
the_bkg4_mu = bkgParmCentInt.bkg4_mu ; bkgParmCentInt.bkg4_sigma =bkgParmCentInt.bkg4_sigma;
the_bkg4_lambda = bkgParmCentInt.bkg4_lambda ; the_bkg4_lambda2 = bkgParmCentInt.bkg4_lambda2 ;
}
// if ( inputOption == kChPol3 )
RooRealVar ch3_k1("pol3_k1","pol3_k1", the_ch3_k1 ) ;
RooRealVar ch3_k2("pol3_k2","pol3_k2", the_ch3_k2 ) ;
RooRealVar ch3_k3("pol3_k3","pol3_k3", the_ch3_k3 ) ;
// if ( inputOption == kChPol4 )
RooRealVar ch4_k1("pol4_k1","pol4_k1", the_ch4_k1 , the_ch4_k1*0.3, the_ch4_k1*1.6) ;
RooRealVar ch4_k2("pol4_k2","pol4_k2", the_ch4_k2 , the_ch4_k2*0.3, the_ch4_k2*1.6) ;
RooRealVar ch4_k3("pol4_k3","pol4_k3", the_ch4_k3 , the_ch4_k3*0.3, the_ch4_k3*1.6) ;
RooRealVar ch4_k4("pol4_k4","pol4_k4", the_ch4_k4 , the_ch4_k4*0.3, the_ch4_k4*1.6) ;
// if (inputOption == kErrExpExp )
RooRealVar err4_mu("err4_mu","err4_mu", the_bkg4_mu , the_bkg4_mu*0.4,the_bkg4_mu*1.4) ;
RooRealVar err4_sigma("err4_sigma","err4_sigma", the_bkg4_sigma, the_bkg4_sigma*0.4, the_bkg4_sigma*1.4);
RooRealVar m4_decay("err4_lambda","m4_decay", the_bkg4_lambda, the_bkg4_lambda*0.4, the_bkg4_lambda*1.4);
RooRealVar m4_decay2("err4_lambda2","m4_decay2", the_bkg4_lambda2, the_bkg4_lambda2*0.4, the_bkg4_lambda2*1.4);
RooGenericPdf *bkgErrExp1;
RooGenericPdf *bkgErrExp2;
RooGenericPdf *bkg4ErrExp ; // kErrExpExp
RooGenericPdf *bkg4Exp = new RooGenericPdf("bkg4Exp","bkg4Exp","TMath::Exp(-@0/@1)",RooArgList(mass,m4_decay2));
if ( ptLow == 0) {
bkg4ErrExp = new RooGenericPdf("bkg4ErrExp","bkg4ErrExp","(TMath::Erf((@0-@1)/(TMath::Sqrt(2)*@2))+1)*0.5*TMath::Exp(-@0/@3)",RooArgList(mass,err4_mu,err4_sigma,m4_decay));
bkgErrExp1 = new RooGenericPdf("bkgErrExp1","Background1","(TMath::Erf((@0-@1)/(TMath::Sqrt(2)*@2))+1)*0.5*TMath::Exp(-@0/@3)",RooArgList(mass,err_mu1,err_sigma1,m_decay1));
bkgErrExp2 = new RooGenericPdf("bkgErrExp2","Background2","(TMath::Erf((@0-@1)/(TMath::Sqrt(2)*@2))+1)*0.5*TMath::Exp(-@0/@3)",RooArgList(mass,err_mu2,err_sigma2,m_decay2));
}
else { // if ptLow >= 5
bkg4ErrExp = new RooGenericPdf("bkg4ErrExp","bkg4ErrExp", "TMath::Exp(-@0/@1)",RooArgList(mass,m4_decay));
bkgErrExp1 = new RooGenericPdf("bkgErrExp1","Background1","TMath::Exp(-@0/@1)",RooArgList(mass,m_decay1));
bkgErrExp2 = new RooGenericPdf("bkgErrExp2","Background2","TMath::Exp(-@0/@1)",RooArgList(mass,m_decay2));
}
RooRealVar* rBkg2nd = new RooRealVar("rBkg2over1","rBkg2over1", bkgParm.rBkg42over1); // bkgParm.rBkgErr2over1
RooAddPdf* bkgDblErr = new RooAddPdf("bkgDblErrExp","Bkg Only",RooArgList(*bkgErrExp2, *bkgErrExp1),RooArgList(*rBkg2nd)); // if ( inputOption == kErrExp )
RooAddPdf* bkgComp4 = new RooAddPdf("bkgComp4","bkgComp4",RooArgList(*bkg4Exp, *bkg4ErrExp),RooArgList(*rBkg2nd)); // if ( inputOption == kErrExp )
RooChebychev * bkgChPol3 = new RooChebychev("cPolBkg","Background1",mass,RooArgSet(ch3_k1,ch3_k2,ch3_k3)); // if ( inputOption == kChPol3 )
RooChebychev * bkgChPol4 = new RooChebychev("cPol4Bkg","Background4",mass,RooArgSet(ch4_k1,ch4_k2,ch4_k3,ch4_k4)); // if ( inputOption == kChPol3 )
float r1S_overTot = bkgParm.nSignal1s / ( bkgParm.nSignal1s + bkgParm.nSignal2s + bkgParm.nBkg ) ; // Numbers obtained from the real data
float r2S_overTot = bkgParm.nSignal2s / ( bkgParm.nSignal1s + bkgParm.nSignal2s + bkgParm.nBkg ) ;
float rBkg_overTot = bkgParm.nBkg / ( bkgParm.nSignal1s + bkgParm.nSignal2s + bkgParm.nBkg ) ;
RooRealVar *nSig1sInp = new RooRealVar("nSig1sInp","nSig1sInp", nGen * r1S_overTot, 0, nGen);
RooRealVar *nSig2sInp = new RooRealVar("nSig2sInp","nSig2sInp", nGen * r2S_overTot, 0, nGen);
RooRealVar *nBkgInp = new RooRealVar("nBkgInp","n_bkgInp", nGen * rBkg_overTot, 0, nGen);
//----------------------------------------------------------------------------------------
//Generating function from nominal fit
RooRealVar err_mu_gen("err_mu_gen","err_mu_gen", bkgParm.bkg_mu_res) ;
RooRealVar err_sigma_gen("err_sigma_gen","err_sigma_gen", bkgParm.bkg_sigma_res);
RooRealVar m_decay_gen("err_lambda_gen","m_decay_gen", bkgParm.bkg_lambda_res);
err_mu_gen.setVal(bkgParm.bkg_mu_res); err_mu_gen.setConstant();
err_sigma_gen.setVal(bkgParm.bkg_sigma_res); err_sigma_gen.setConstant();
m_decay_gen.setVal(bkgParm.bkg_lambda_res); m_decay_gen.setConstant();
RooGenericPdf* bkgInp_gen;
RooGenericPdf *bkgInp_in;
if ( ptLow == 0) {
bkgInp_in = new RooGenericPdf("bkgInp_gen","Background Gen","(TMath::Erf((@0-@1)/(TMath::Sqrt(2)*@2))+1)*0.5*TMath::Exp(-@0/@3)",RooArgList(mass,err_mu_gen,err_sigma_gen,m_decay_gen));
}
else {
bkgInp_in = new RooGenericPdf("bkgInp_gen","Background Gen","TMath::Exp(-@0/@1)",RooArgList(mass,m_decay_gen));
}
bkgInp_gen = bkgInp_in;
RooAddPdf* modelInput_gen;
modelInput_gen = new RooAddPdf("modelInput_gen","1S+2S + Bkg",RooArgList(*cb1s, *cb2s, *bkgInp_gen),RooArgList(*nSig1sInp,*nSig2sInp,*nBkgInp));
//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
RooAddPdf* modelInput;
RooGenericPdf* bkgInp;
if ( inputOption == kErrExp ) {
bkgInp = (RooGenericPdf*) bkgDblErr;
}
else if ( inputOption == kChPol3 ) {
bkgInp = (RooGenericPdf*) bkgChPol3;
}
else if ( inputOption == kChPol4 ) {
bkgInp = (RooGenericPdf*) bkgChPol4;
}
else if ( inputOption == kErrExpExp ) {
bkgInp = (RooGenericPdf*) bkgComp4;
}
modelInput = new RooAddPdf("modelInput","1S+2S + Bkg",RooArgList(*cb1s, *cb2s, *bkgInp),RooArgList(*nSig1sInp,*nSig2sInp,*nBkgInp));
wsinp->import(*modelInput);
Val_2S_1S_nom=0;
Val_2S_1S_alt=0;
Dev_2S_1S=0;
RooDataSet *data = modelInput_gen->generate(mass,nGen) ;
RooPlot* xframe = ws->var("mass")->frame(nMassBin); // bins
xframe->SetXTitle("mass (Gev/c^{2})");
xframe->GetXaxis()->CenterTitle();
xframe->GetYaxis()->CenterTitle();
RooPlot* xframe2 = (RooPlot*)xframe->Clone("xframe2");
RooFitResult* fitResInput = wsinp->pdf("modelInput")->fitTo(*data,Save(), Hesse(kTRUE),Range(massLow, massHigh),Minos(0), SumW2Error(kTRUE));
data->plotOn(xframe,Name("dataHist"),MarkerSize(0.7)) ;
wsinp->pdf("modelInput")->plotOn(xframe, Name("inputModelHist"));
wsinp->pdf("modelInput")->plotOn(xframe, Components(RooArgSet(*bkgInp)),LineColor(kBlack),LineStyle(kDashed));
if ( inputOption == kErrExp )
{
modelInput->plotOn(xframe,Components(RooArgSet(*bkgDblErr)),LineColor(kRed),LineStyle(kDashed));
modelInput->plotOn(xframe,Components(RooArgSet(*bkgErrExp1)),LineColor(kBlack),LineStyle(kDashed));
modelInput->plotOn(xframe,Components(RooArgSet(*bkgErrExp2)),LineColor(kBlack),LineStyle(kDashed));
}
else if ( inputOption == kChPol3 )
modelInput->plotOn(xframe,Components(RooArgSet(*bkgChPol3)),LineColor(kBlack),LineStyle(kDashed));
else if ( inputOption == kChPol4 )
modelInput->plotOn(xframe,Components(RooArgSet(*bkgChPol4)),LineColor(kBlack),LineStyle(kDashed));
else if (inputOption == kErrExpExp ) {
modelInput->plotOn(xframe,Components(RooArgSet(*bkgComp4)),LineColor(kBlack),LineStyle(kDashed));
modelInput->plotOn(xframe,Components(RooArgSet(*bkg4ErrExp)),LineColor(kBlack),LineStyle(kDashed));
modelInput->plotOn(xframe,Components(RooArgSet(*bkg4Exp)),LineColor(kBlack),LineStyle(kDashed));
}
// New fit
float the_bkg_mu = bkgParm.bkg_mu ;
float the_bkg_sigma = bkgParm.bkg_sigma ;
float the_bkg_lambda = bkgParm.bkg_lambda ;
if ( !( (cLow==0) && (cHigh==200) ) && (collId==kAADATA) && useCentIntBkgShape ) {
the_bkg_mu = bkgParmCentInt.bkg_mu ;
the_bkg_sigma = bkgParmCentInt.bkg_sigma ;
the_bkg_lambda = bkgParmCentInt.bkg_lambda ;
}
//RooRealVar err_mu("err_mu","err_mu", the_bkg_mu, 0.0, 40);
RooRealVar err_mu("err_mu","err_mu", the_bkg_mu, the_bkg_mu*0.4, the_bkg_mu*1.4);
//RooRealVar err_mu("err_mu","err_mu", 1., 0.0, 30);
//RooRealVar err_sigma("err_sigma","err_sigma", 1.2, 1.1,55);
//RooRealVar err_sigma("err_sigma","err_sigma", 10.,0,20);
RooRealVar err_sigma("err_sigma","err_sigma", the_bkg_sigma, the_bkg_sigma*0.4, the_bkg_sigma*1.4);
//RooRealVar m_decay("m_decay","m_decay", 10., 6.5, 30);
RooRealVar m_decay("m_decay","m_decay",the_bkg_lambda, the_bkg_lambda*0.4, the_bkg_lambda*1.4);
if( ( ptLow == (float)0 ) && (ptHigh == (float)30 ) && (yLow == (float)0 ) && (yHigh == (float)2.4) && collId==kPPDATA)
{
err_sigma.setVal(1.055);
err_sigma.setConstant();
}
if( ( ptLow == (float)0 ) && (ptHigh == (float)30 ) && (yLow == (float)0 ) && (yHigh == (float)2.4) && collId==kAADATA)
{
err_sigma.setVal(1.103);
err_sigma.setConstant();
}
RooGenericPdf *bkgFitOut;
if ( ptLow == 0) {
bkgFitOut = new RooGenericPdf("bkgFitOut","BackgroundOut","(TMath::Erf((@0-@1)/(TMath::Sqrt(2)*@2))+1)*0.5*TMath::Exp(-@0/@3)",RooArgList(mass,err_mu,err_sigma,m_decay));
}
else {
bkgFitOut = new RooGenericPdf("bkgFitOut","BackgroundOut","TMath::Exp(-@0/@1)",RooArgList(mass,m_decay));
}
RooRealVar *nSig1sOut = new RooRealVar("nSig1sOut","nSig1sOut", r1S_overTot*nGen, 0, r1S_overTot*2.*nGen);
RooRealVar *nSig2sOut = new RooRealVar("nSig2sOut","nSig2sOut", r2S_overTot*nGen, 0, r2S_overTot*2.*nGen);
RooRealVar *nBkgOut = new RooRealVar("nBkgOut","n_bkgOut",nGen * rBkg_overTot, 0, nGen);
RooAddPdf* cb1sOut = (RooAddPdf*)cb1s->Clone("cb1sOutput");
RooAddPdf* cb2sOut = (RooAddPdf*)cb2s->Clone("cb2sOutput");
RooAddPdf* modelOutput = new RooAddPdf("modelOutput","1S+2S + Bkg",RooArgList(*cb1sOut, *cb2sOut, *bkgFitOut),RooArgList(*nSig1sOut,*nSig2sOut,*nBkgOut));
ws->import(*modelOutput);
RooFitResult* fitRes = ws->pdf("modelOutput")->fitTo(*data,Save(), Hesse(kTRUE),Range(massLow, massHigh),Minos(0), SumW2Error(kTRUE));
data->plotOn(xframe2,Name("dataHist2"),MarkerSize(0.7)) ;
ws->pdf("modelOutput")->plotOn(xframe2, Name("outputModelHist"));
ws->pdf("modelOutput")->plotOn(xframe2, Components(RooArgSet(*bkgFitOut)),LineColor(kBlack),LineStyle(kDashed));
Val_2S_1S_nom = (float)(ws->var("nSig2sOut")->getVal() / ws->var("nSig1sOut")->getVal());
Val_2S_1S_alt = (float)(wsinp->var("nSig2sInp")->getVal() / wsinp->var("nSig1sInp")->getVal());
Dev_2S_1S = (Val_2S_1S_alt/Val_2S_1S_nom - 1) * 100;
h1->Fill(Val_2S_1S_nom);
h2->Fill(Val_2S_1S_alt);
h3->Fill(Dev_2S_1S);
// DRAW!
if(i == 0){
TCanvas* c1 = new TCanvas("canvas2","My plots",4,45,800,400);
c1->cd();
TPad *pad1 = new TPad("pad1", "pad1", 0, 0.25, 0.49, 1.0);
pad1->SetTicks(1,1);
pad1->Draw(); pad1->cd();
pad1->SetBottomMargin(0); // Upper and lower plot are joined
xframe->GetYaxis()->SetTitleOffset(1.4) ; xframe->Draw() ;
drawText(Form("#Upsilon(2S)/#Upsilon(1S) = %.5f",(float)(wsinp->var("nSig2sInp")->getVal() / wsinp->var("nSig1sInp")->getVal())),0.2,0.54,1,16) ;
if (inputOption==kChPol4 )
drawText("4th order poly. Bkg.",0.2,0.62,2,15) ;
if (inputOption==kErrExpExp )
drawText("Erf*exp + exp Bkg.",0.2,0.62,2,15) ;
if(collId == kAADATA)
drawText("PbPb",0.4,0.45,1,15);
if(collId == kPPDATA)
drawText("pp", 0.4,0.45,1,15);
drawText(Form("%.1f < p_{T}^{#mu#mu} < %.1f GeV",ptLow,ptHigh ),0.5,0.60,1,12);
drawText(Form("%.1f < y^{#mu#mu} < %.1f",yLow,yHigh ), 0.5,0.55,1,12);
TString perc = "%";
if(collId == kAADATA)
drawText(Form("Cent %d-%d%s",cLow/2,cHigh/2,perc.Data()),0.5,0.5,4,12);
TLatex *tex = new TLatex(0.4,0.88,"Toy MC generated");
tex->SetTextFont(43);
tex->SetTextSize(15);
tex->SetNDC();
// tex->SetTextAngle(180);
tex->Draw();
RooArgList paramListinp = fitResInput->floatParsFinal();
paramListinp.Print("v");
RooPlot* legFrameinp = wsinp->var("mass")->frame(Name("Fit Results"), Title("Fit Results"));
wsinp->pdf("modelInput")->paramOn(legFrameinp,Layout(.6,.9, .5),Parameters(paramListinp));
legFrameinp->getAttText()->SetTextAlign(11);
legFrameinp->getAttText()->SetTextSize(0.028);
TPaveText* hhinp = (TPaveText*)legFrameinp->findObject(Form("%s_paramBox",wsinp->pdf("modelInput")->GetName()));
hhinp->SetY1(0.35); hhinp->SetY2(0.83);
hhinp->Draw();
// PULL
TPad *pad2 = new TPad("pad2", "pad2", 0, 0.05, 0.49, 0.25);
c1->cd();
pad2->Draw();
pad2->cd();
RooHist* hpull = xframe->pullHist("dataHist","inputModelHist");
RooPlot* pullFrame = wsinp->var("mass")->frame(Title("Pull Distribution")) ;
pullFrame->addPlotable(hpull,"P") ;
pullFrame->SetTitleSize(2.57);
pullFrame->GetYaxis()->SetTitleOffset(1.8) ;
pullFrame->GetYaxis()->SetLabelSize(0.16) ;
pullFrame->GetYaxis()->SetRange(-10,10) ;
pullFrame->GetXaxis()->SetTitleOffset(0.7) ;
pullFrame->GetXaxis()->SetLabelSize(0.1) ;
pullFrame->GetXaxis()->SetTitleSize(0.13) ;
pullFrame->Draw() ;
TPad *pad3 = new TPad("pad3", "pad3", 0.51, 0.25, 0.99, 1);
pad3->SetTicks(1,1);
pad3->SetBottomMargin(0); // Upper and lower plot are joined
c1->cd();
pad3->Draw(); pad3->cd();
xframe2->GetYaxis()->SetTitleOffset(1.4) ; xframe2->Draw() ;
TLatex *tex2 = new TLatex(0.4,0.9,"Fitted by Nominal function");
tex2->SetTextFont(43);
tex2->SetTextSize(15);
tex2->SetTextColor(2);
tex2->SetNDC();
tex2->Draw();
drawText(Form("#Upsilon(2S)/#Upsilon(1S) = %.5f",(float)(ws->var("nSig2sOut")->getVal() / ws->var("nSig1sOut")->getVal())), 0.4,0.85,1,16 );
// *~*~*~*~*~*~*~* Draw the parameters in the plot *~*~*~*~*~*~*~* //
RooArgList paramList = fitRes->floatParsFinal();
paramList.Print("v");
RooPlot* legFrame = ws->var("mass")->frame(Name("Fit Results"), Title("Fit Results"));
ws->pdf("modelOutput")->paramOn(legFrame,Layout(.6,.9, .5),Parameters(paramList));
legFrame->getAttText()->SetTextAlign(11);
legFrame->getAttText()->SetTextSize(0.028);
TPaveText* hh = (TPaveText*)legFrame->findObject(Form("%s_paramBox",ws->pdf("modelOutput")->GetName()));
hh->SetY1(0.35); hh->SetY2(0.83);
hh->Draw();
TPad *pad4 = new TPad("pad4", "pad4", 0.51, 0.05, 0.99, 0.25);
// pad4->SetBottomMargin(0); // Upper and lower plot are joined
c1->cd();
pad4->Draw();
pad4->cd();
RooHist* hpullOut = xframe2->pullHist("dataHist2","outputModelHist");
RooPlot* pullOutFrm = ws->var("mass")->frame(Title("Pull Distribution")) ;
pullOutFrm->addPlotable(hpullOut,"P") ;
pullOutFrm->SetTitleSize(2.57);
pullOutFrm->GetYaxis()->SetTitleOffset(1.8) ;
pullOutFrm->GetYaxis()->SetLabelSize(0.16) ;
pullOutFrm->GetYaxis()->SetRange(-10,10) ;
pullOutFrm->GetXaxis()->SetTitleOffset(0.7) ;
pullOutFrm->GetXaxis()->SetLabelSize(0.1) ;
pullOutFrm->GetXaxis()->SetTitleSize(0.13) ;
pullOutFrm->Draw() ;
// *~*~*~*~*~*~*~* Print the results *~*~*~*~*~*~*~* //
//cout << "nSig2sInp/nSig1sInp = " << nSig2sInp->getVal() / nSig1sInp->getVal() << endl;
cout << "input fit ratio = " << wsinp->var("nSig2sInp")->getVal() / wsinp->var("nSig1sInp")->getVal() << endl;
cout << "output fit ratio = " << ws->var("nSig2sOut")->getVal() / ws->var("nSig1sOut")->getVal() << endl;
c1->SaveAs(Form( "toyMCFit_collId%d_pt%.0f-%.0fGeV_y%.0f-%.0f_cBin%d-%d_muPtCut%.0fGeV_BkgPDFOpt%d_nGen%d_useCentIntBkgShape%d.png",
collId, ptLow, ptHigh, yLow*10, yHigh*10, cLow, cHigh, muPtCut, inputOption, nGen,useCentIntBkgShape) );
float r1 = wsinp->var("nSig2sInp")->getVal() / wsinp->var("nSig1sInp")->getVal() ;
float r2 = ws->var("nSig2sOut")->getVal() / ws->var("nSig1sOut")->getVal() ;
cout << Form( "collId: %d, pt: %.0f - %.0fGeV, y: %.1f - %.1f, cBin: %d - %d", collId, ptLow, ptHigh, yLow, yHigh, cLow, cHigh ) << endl;
cout << "Uncertainty = " << (r2 - r1 ) / r1 << endl;
}
}
wf->cd();
h1->Write();
h2->Write();
h3->Write();
}
void fitM3()
{
// LOAD HISTOGRAMS FROM FILES
/////////////////////////////////
TH1F *hTTjets;
TH1F *hWjets;
TH1F *hM3;
TH1F *hZjets;
TH1F *hQCD;
TH1F *hST_s;
TH1F *hST_t;
TH1F *hST_tW;
// histograms from nonimal sample
///////////
TFile *infile0 = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_TTJets-madgraph_Fall08_all_all.root");
//TFile *infile0 = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_TauolaTTbar.root");
hTTjets = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infile1 = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_WJets_madgraph_Fall08_all.root");
hWjets = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infile1Fast = TFile::Open("nominal_IPsig3_Iso95_Fast/TopAnalysis_Wjets_madgraph_Winter09_v2_all.root");
hWjetsFast = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileZ = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_ZJets_madgraph_Fall08_all.root");
hZjets = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileZFast = TFile::Open("nominal_IPsig3_Iso95_Fast/TopAnalysis_Zjets_madgraph_Winter09_v2_all.root");
hZjetsFast = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileST_s = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_ST_s.root");
hST_s = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileST_t = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_ST_t.root");
hST_t = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileST_tW = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_ST_tW.root");
hST_tW = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileQCD = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_InclusiveMuPt15_Summer08_all.root");
hQCD = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
// histograms from systematic samples
//////////
TFile *infile0S = TFile::Open("nominal_JESUp/TopAnalysis_TTJets-madgraph_Fall08_all_all.root");
hTTjetsS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infile1S = TFile::Open("nominal_JESUp/TopAnalysis_WJets_madgraph_Fall08_all.root");// from FullSim
hWjetsS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
//TFile *infile1SF = TFile::Open("nominal_JESUp_Fast/TopAnalysis_WJets_madgraph_Fall08_all.root");// from FastSim
//TFile *infile1SF = TFile::Open("nominal_IPsig3_Iso95_Fast/TopAnalysis_Wjets_ScaleUp_madgraph_Winter09_all.root");
TFile *infile1SF = TFile::Open("nominal_IPsig3_Iso95_Fast/TopAnalysis_WJets_Threshold20GeV_madgraph_Winter09_all.root");
hWjetsSFast = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileZS = TFile::Open("nominal_JESUp/TopAnalysis_ZJets_madgraph_Fall08_all.root");// from FullSim
hZjetsS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileZSF = TFile::Open("nominal_JESUp_Fast/TopAnalysis_ZJets_madgraph_Fall08_all.root");// from FullSim
hZjetsSFast = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileST_sS = TFile::Open("nominal_JESUp/TopAnalysis_ST_s.root");
hST_sS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileST_tS = TFile::Open("nominal_JESUp/TopAnalysis_ST_t.root");
hST_tS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileST_tWS = TFile::Open("nominal_JESUp/TopAnalysis_ST_tW.root");
hST_tWS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
TFile *infileQCDS = TFile::Open("nominal_JESUp/TopAnalysis_InclusiveMuPt15_Summer08_all.root");//
hQCDS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
//TFile *infileQCD_CS = TFile::Open("nominal_antiMuon/TopAnalysis_InclusiveMuPt15_Summer08_all.root");
//hQCD_CS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1");
// write templates to file
//TFile *outfile = TFile::Open("templates.root","RECREATE");
//hTTjets->Write("ttbar");
//hWjets->Write("Wjets");
//outfile->Close();
// Add over/underflow bins if requested
bool UseOverflow = true;
bool UseUnderflow = true;
if (UseOverflow) {
int maxbin=hTTjets->GetNbinsX();
hTTjets->SetBinContent(maxbin, hTTjets->GetBinContent(maxbin+1)+hTTjets->GetBinContent(maxbin) );
hWjets->SetBinContent(maxbin, hWjets->GetBinContent(maxbin+1)+hWjets->GetBinContent(maxbin) );
hWjetsFast->SetBinContent(maxbin, hWjetsFast->GetBinContent(maxbin+1)+hWjetsFast->GetBinContent(maxbin) );
hZjets->SetBinContent(maxbin, hZjets->GetBinContent(maxbin+1)+hZjets->GetBinContent(maxbin) );
hZjetsFast->SetBinContent(maxbin, hZjetsFast->GetBinContent(maxbin+1)+hZjetsFast->GetBinContent(maxbin) );
hQCD->SetBinContent(maxbin, hQCD->GetBinContent(maxbin+1)+hQCD->GetBinContent(maxbin) );
//hQCD_CS->SetBinContent(maxbin, hQCD_CS->GetBinContent(maxbin+1)+hQCD_CS->GetBinContent(maxbin) );
hST_s->SetBinContent(maxbin, hST_s->GetBinContent(maxbin+1)+hST_s->GetBinContent(maxbin) );
hST_t->SetBinContent(maxbin, hST_t->GetBinContent(maxbin+1)+hST_t->GetBinContent(maxbin) );
hST_tW->SetBinContent(maxbin, hST_tW->GetBinContent(maxbin+1)+hST_tW->GetBinContent(maxbin) );
}
//underflow bin
if (UseUnderflow) {
int maxbin=1;
hTTjets->SetBinContent(maxbin, hTTjets->GetBinContent(maxbin-1)+hTTjets->GetBinContent(maxbin) );
hWjets->SetBinContent(maxbin, hWjets->GetBinContent(maxbin-1)+hWjets->GetBinContent(maxbin) );
hWjetsFast->SetBinContent(maxbin, hWjetsFast->GetBinContent(maxbin-1)+hWjetsFast->GetBinContent(maxbin) );
hZjets->SetBinContent(maxbin, hZjets->GetBinContent(maxbin-1)+hZjets->GetBinContent(maxbin) );
hZjetsFast->SetBinContent(maxbin, hZjetsFast->GetBinContent(maxbin-1)+hZjetsFast->GetBinContent(maxbin) );
hQCD->SetBinContent(maxbin, hQCD->GetBinContent(maxbin-1)+hQCD->GetBinContent(maxbin) );
//hQCD_CS->SetBinContent(maxbin, hQCD_CS->GetBinContent(maxbin-1)+hQCD_CS->GetBinContent(maxbin) );
hST_s->SetBinContent(maxbin, hST_s->GetBinContent(maxbin-1)+hST_s->GetBinContent(maxbin) );
hST_t->SetBinContent(maxbin, hST_t->GetBinContent(maxbin-1)+hST_t->GetBinContent(maxbin) );
hST_tW->SetBinContent(maxbin, hST_tW->GetBinContent(maxbin-1)+hST_tW->GetBinContent(maxbin) );
}
//syst.
if (UseOverflow) {
int maxbin=hTTjetsS->GetNbinsX();
hTTjetsS->SetBinContent(maxbin, hTTjetsS->GetBinContent(maxbin+1)+hTTjetsS->GetBinContent(maxbin) );
hWjetsS->SetBinContent(maxbin, hWjetsS->GetBinContent(maxbin+1)+hWjetsS->GetBinContent(maxbin) );
hWjetsSFast->SetBinContent(maxbin, hWjetsSFast->GetBinContent(maxbin+1)+hWjetsSFast->GetBinContent(maxbin) );
hZjetsS->SetBinContent(maxbin, hZjetsS->GetBinContent(maxbin+1)+hZjetsS->GetBinContent(maxbin) );
hZjetsSFast->SetBinContent(maxbin, hZjetsSFast->GetBinContent(maxbin+1)+hZjetsSFast->GetBinContent(maxbin) );
hQCDS->SetBinContent(maxbin, hQCDS->GetBinContent(maxbin+1)+hQCDS->GetBinContent(maxbin) );
hST_sS->SetBinContent(maxbin, hST_sS->GetBinContent(maxbin+1)+hST_sS->GetBinContent(maxbin) );
hST_tS->SetBinContent(maxbin, hST_tS->GetBinContent(maxbin+1)+hST_tS->GetBinContent(maxbin) );
hST_tWS->SetBinContent(maxbin, hST_tWS->GetBinContent(maxbin+1)+hST_tWS->GetBinContent(maxbin) );
}
if (UseUnderflow) {
//underflow bin
int maxbin=1;
hTTjetsS->SetBinContent(maxbin, hTTjetsS->GetBinContent(maxbin-1)+hTTjetsS->GetBinContent(maxbin) );
hWjetsS->SetBinContent(maxbin, hWjetsS->GetBinContent(maxbin-1)+hWjetsS->GetBinContent(maxbin) );
hWjetsSFast->SetBinContent(maxbin, hWjetsSFast->GetBinContent(maxbin-1)+hWjetsSFast->GetBinContent(maxbin) );
hZjetsS->SetBinContent(maxbin, hZjetsS->GetBinContent(maxbin-1)+hZjetsS->GetBinContent(maxbin) );
hZjetsSFast->SetBinContent(maxbin, hZjetsSFast->GetBinContent(maxbin-1)+hZjetsSFast->GetBinContent(maxbin) );
hQCDS->SetBinContent(maxbin, hQCDS->GetBinContent(maxbin-1)+hQCDS->GetBinContent(maxbin) );
hST_sS->SetBinContent(maxbin, hST_sS->GetBinContent(maxbin-1)+hST_sS->GetBinContent(maxbin) );
hST_tS->SetBinContent(maxbin, hST_tS->GetBinContent(maxbin-1)+hST_tS->GetBinContent(maxbin) );
hST_tWS->SetBinContent(maxbin, hST_tWS->GetBinContent(maxbin-1)+hST_tWS->GetBinContent(maxbin) );
}
// scale histograms to 20/pb
hTTjets->Scale(0.0081); // madgraph
//hTTjets->Scale(0.0777);//Tauola
hWjets->Scale(0.0883);
//hWjetsFast->Scale(0.0091); //fastsim
hWjetsFast->Scale(hWjets->Integral() / hWjetsFast->Integral()); // scale to FullSim
hZjets->Scale(0.0731);
hZjetsFast->Scale(hZjets->Integral()/hZjetsFast->Integral()); //scale to FullSim
hQCD->Scale(0.4003);
hQCD_WFast = (TH1F*) hWjetsFast->Clone("hQCD_WFast"); //take shape from Wjets
hQCD_WFast->Scale(hQCD->Integral()/hQCD_WFast->Integral()); //scale to FullSim
hST_t->Scale(0.003);
hST_s->Scale(0.0027);
hST_tW->Scale(0.0034);
hTTjetsS->Scale(0.0081); //
//hTTjetsS->Scale(0.0008); // for fastsim
hWjetsS->Scale(0.0883);
//hWjetsS->Scale(0.0091);// from fastsim
//hWjetsSFast->Scale(hWjetsS->Integral() / hWjetsSFast->Integral()); // scale to FullSim
//hWjetsSFast->Scale(0.6642); // scaleUP
//hWjetsSFast->Scale(0.8041); // scaleDown
//hWjetsSFast->Scale(0.0605); // threshold 5gev
hWjetsSFast->Scale(0.042); // threshold 20gev
hZjetsS->Scale(0.0731);
//hZjetsS->Scale(0.0085);// from fastsim
hZjetsSFast->Scale(hZjetsS->Integral() / hZjetsSFast->Integral()); // scale to FullSim
hQCDS->Scale(0.4003);
//hQCDS_WFast = (TH1F*) hWjetsS->Clone("hQCDS_WFast");
//hQCDS_WFast->Scale(hQCDS->Integral()/hQCDS_WFast->Integral());
hST_tS->Scale(0.003);
hST_sS->Scale(0.0027);
hST_tWS->Scale(0.0034);
cout << " N expected ttbar+jets events = " << hTTjets->Integral() << endl;
cout << " N expected W+jets events = " << hWjets->Integral() << endl;
cout << " N expected Z+jets events = " << hZjets->Integral() << endl;
cout << " N expected ST s events = " << hST_s->Integral() << endl;
cout << " N expected ST t events = " << hST_t->Integral() << endl;
cout << " N expected ST tW events = " << hST_tW->Integral() << endl;
cout << " N expected qcd events = " << hQCD->Integral() << endl;
cout << endl;
cout << " N expected W+jets fast = " << hWjetsFast->Integral() << endl;
cout << " N expected z+jets fast = " << hZjetsFast->Integral() << endl;
cout << " N expected qcd Wfast = " << hQCD_WFast->Integral() << endl;
cout << "\n systematics: " << endl;
cout << " N expected W+jets fast = " << hWjetsSFast->Integral() << endl;
cout << " N expected z+jets fast = " << hZjetsS->Integral() << endl;
cout << " N expected qcd Wfast = " << hQCDS->Integral() << endl;
// add all three single top samples
// for systematics
//hST_t->Scale(2.);
hST_t->Add(hST_s);
hST_t->Add(hST_tW);
cout << " number of ST = " << hST_t->Integral() << endl;
// syst. uncertainty in single top
//double tmpST = 0.6* hST_t->Integral();
//hST_t->Scale(0.6);
//cout << tmpST << endl;
cout << " New number of ST = " << hST_t->Integral() << endl;
hST_tS->Add(hST_sS);
hST_tS->Add(hST_tWS);
// dump scaled histograms in root file
//TFile *output = TFile::Open("fitM3.root","RECREATE");
//hTTjets->SetName("ttbar");hTTjets->Write();
//hWjetsFast->SetName("WjetsFast");hWjetsFast->Write();
//hST_t->SetName("ST");hST_t->Write();
//output->Close();
hM3 = (TH1F*) hTTjets->Clone("hM3");
hM3->Add(hWjets);
hM3->Add(hZjets);
hM3->Add(hQCD);
hM3->Add(hST_t);
int Nbins = hM3->GetNbinsX();
// --- Observable ---
RooRealVar mass("mass","M3'(#chi^{2})",100,500,"GeV/c^{2}") ;
RooRealVar Ntt("Ntt","number of t#bar{t} events", hTTjets->Integral(), -100 , 1000);
RooRealVar NW("NW","number of W+jets events", hWjetsFast->Integral(), -500 , 1000);
RooRealVar NST("NST","number of single top events", hST_t->Integral(), -500,100);
RooRealVar NZjets("NZjets","number of Z+jets events", hZjetsS->Integral(), -500,500);
RooRealVar Nqcd("Nqcd","number of QCD events", hQCD_WFast->Integral(), -500,100);
//RooRealVar Nbkg("Nbkg","number of bkg events", hWjetsFast->Integral()+hST_t->Integral()+hZjetsFast->Integral()+hQCD_WFast->Integral(), -500 , 1000);
//RooRealVar Nbkg("Nbkg","number of W+jets events", hWjets->Integral(), -500 , 1000); // 2 templates
RooRealVar Nbkg("Nbkg","number of bkg events", hWjetsFast->Integral()+hZjets->Integral()+hQCD_WFast->Integral(), -500 , 1000);
//RooRealVar Nbkg("Nbkg","number of bkg events", hWjetsFast->Integral(), -500 , 1000);
// for systematics
//RooRealVar Nbkg("Nbkg","number of bkg events", hWjetsSFast->Integral()+hZjetsS->Integral()+hQCDS->Integral(), -500 , 1000);
//RooRealVar Nbkg("Nbkg","number of bkg events", hWjetsSFast->Integral(), -500 , 1000);
mass.setBins(Nbins);
// RooFit datasets
RooDataHist hdata_ttbar("hdata_ttbar","ttbar", mass, hTTjets);
//RooDataHist hdata_wjets("hdata_wjets","wjets", mass, hWjets);
RooDataHist hdata_wjetsFast("hdata_wjetsFast","wjets_Fast", mass, hWjetsFast);
RooDataHist hdata_ST("hdata_ST","ST", mass, hST_t);
RooDataHist hdata_zjets("hdata_zjets","zjets", mass, hZjets);
//RooDataHist hdata_qcd("hdata_qcd","qcd", mass, hQCD);
RooDataHist hdata_zjetsFast("hdata_zjetsFast","zjets_Fast", mass, hZjetsFast);
RooDataHist hdata_qcdWFast("hdata_qcdWFast","qcd WFast", mass, hQCD_WFast);
RooHistPdf hpdf_ttbar("hpdf_ttbar","signal pdf", mass, hdata_ttbar, 0 );
//RooHistPdf hpdf_wjets("hpdf_wjets","W+jets pdf", mass, hdata_wjets, 0 );
RooHistPdf hpdf_wjetsFast("hpdf_wjetsFast","W+jets pdf", mass, hdata_wjetsFast, 0 );
RooHistPdf hpdf_ST("hpdf_ST","ST pdf", mass, hdata_ST, 0 );
//RooHistPdf hpdf_zjets("hpdf_zjets","Z+jets pdf", mass, hdata_zjets, 0 );
//RooHistPdf hpdf_qcd("hpdf_qcd","qcd pdf", mass, hdata_qcd, 0 );
RooHistPdf hpdf_zjetsFast("hpdf_zjetsFast","Z+jets pdf", mass, hdata_zjetsFast, 0 );
RooHistPdf hpdf_qcdWFast("hpdf_qcdWFast","qcd WFast pdf", mass, hdata_qcdWFast, 0 );
// for systematics
RooDataHist hdata_ttbarS("hdata_ttbarS","ttbar", mass, hTTjetsS);
RooDataHist hdata_wjetsS("hdata_wjetsS","wjets", mass, hWjetsSFast);
RooDataHist hdata_STS("hdata_STS","ST", mass, hST_tS);
RooDataHist hdata_zjetsS("hdata_zjetsS","zjets", mass, hZjetsSFast);
RooDataHist hdata_qcdS("hdata_qcdS","qcd", mass, hQCDS);
//RooDataHist hdata_qcdSWFast("hdata_qcdSWFast","qcd WFast", mass, hQCDS_WFast);
RooHistPdf hpdf_ttbarS("hpdf_ttbarS","signal pdf", mass, hdata_ttbarS, 0 );
RooHistPdf hpdf_wjetsS("hpdf_wjetsS","W+jets pdf", mass, hdata_wjetsS, 0 );
RooHistPdf hpdf_STS("hpdf_STS","ST pdf", mass, hdata_STS, 0 );
RooHistPdf hpdf_zjetsS("hpdf_zjetsS","Z+jets pdf", mass, hdata_zjetsS, 0 );
RooHistPdf hpdf_qcdS("hpdf_qcdS","qcd pdf", mass, hdata_qcdS, 0 );
//RooHistPdf hpdf_qcdSWFast("hpdf_qcdSWFast","qcd WFast pdf", mass, hdata_qcdSWFast, 0 );
//RooAddPdf hpdf_bkg("hpdf_bkg","bkg", RooArgList(hpdf_wjetsFast,hpdf_ST,hpdf_qcdWFast),
// RooArgList(NW,NST,Nqcd) );
//RooAddPdf hpdf_bkg("hpdf_bkg","bkg", RooArgList(hpdf_wjetsFast,hpdf_ST,hpdf_zjetsFast,hpdf_qcdWFast),
//RooAddPdf hpdf_bkg("hpdf_bkg","bkg", RooArgList(hpdf_wjetsS,hpdf_STS,hpdf_zjetsS,hpdf_qcdSWFast),
//RooArgList(NW,NST,NZjets,Nqcd) );
// only two pdfs: ttbar + Wjets
//RooHistPdf hpdf_bkg = hpdf_wjetsFast;
//RooAddPdf model_M3("modelM3","all", RooArgList(hpdf_ttbar,hpdf_wjetsFast,hpdf_ST,hpdf_zjetsFast,hpdf_qcdWFast),
// RooArgList(Ntt,Nbkg,NST,NZjets,Nqcd));
// for systematics
RooAddPdf model_M3("modelM3","all", RooArgList(hpdf_ttbar,hpdf_wjetsFast,hpdf_ST),//RooArgList(hpdf_ttbar,hpdf_wjetsS,hpdf_ST),
RooArgList(Ntt,Nbkg,NST) );
//RooAddPdf model_M3("modelM3","all",RooArgList(hpdf_ttbar,hpdf_bkg),
// RooArgList(Ntt,Nbkg) );
//RooArgList(Ntt,Nbkg,NST,Nqcd) );
RooAddPdf model_histpdf("model", "TTjets+Wjets", RooArgList(hpdf_ttbar,hpdf_wjetsFast,hpdf_ST),
RooArgList(Ntt, Nbkg, NST) ) ;
// Construct another Gaussian constraint p.d.f on parameter f at n with resolution of sqrt(n)
RooGaussian STgaussConstraint("STgaussConstraint","STgaussConstraint",NST,RooConst(hST_t->Integral()),RooConst(sqrt(hST_t->Integral() + (0.3*hST_t->Integral())*(0.3*hST_t->Integral()))) );
//RooGaussian fconstext2("fconstext2","fconstext2",NZjets,RooConst(hZjets->Integral()),RooConst(sqrt(hZjets->Integral())) );
// --- Generate a toyMC sample
//RooMCStudy *mcstudyM3 = new RooMCStudy(model_M3, mass, Binned(kTRUE),Silence(),Extended(),
// FitOptions(Save(kTRUE),Minos(kTRUE),Extended(), ExternalConstraints(fconstext)) );
// generate PEs
int Nsamples = 1000;
// PEs for ttbar
/*
RooExtendPdf ext_hpdf_ttbar("ext_hpdf_ttbar","ext_hpdf_ttbar",hpdf_ttbar,Ntt);
RooExtendPdf ext_hpdf_wjets("ext_hpdf_wjets","ext_hpdf_wjets",hpdf_wjetsFast,NW);
RooExtendPdf ext_hpdf_zjets("ext_hpdf_zjets","ext_hpdf_zjets",hpdf_zjetsFast,NZjets);
RooExtendPdf ext_hpdf_qcd("ext_hpdf_qcd","ext_hpdf_qcd",hpdf_qcdWFast,Nqcd);
RooExtendPdf ext_hpdf_ST("ext_hpdf_ST","ext_hpdf_ST",hpdf_ST,NST);
RooMCStudy *mc_ttbar = new RooMCStudy(ext_hpdf_ttbar,mass,Binned(kTRUE),Silence(kTRUE));
mc_ttbar->generate(Nsamples,0,kFALSE,"data/toymc_ttbar_%04d.dat");
RooMCStudy *mc_wjets = new RooMCStudy(ext_hpdf_wjets,mass,Binned(kTRUE),Silence(kTRUE));
mc_wjets->generate(Nsamples,0,kFALSE,"data/toymc_wjets_%04d.dat");
RooMCStudy *mc_zjets = new RooMCStudy(ext_hpdf_zjets,mass,Binned(kTRUE),Silence(kTRUE));
mc_zjets->generate(Nsamples,0,kFALSE,"data/toymc_zjets_%04d.dat");
RooMCStudy *mc_qcd = new RooMCStudy(ext_hpdf_qcd,mass,Binned(kTRUE),Silence(kTRUE));
mc_qcd->generate(Nsamples,0,kFALSE,"data/toymc_qcd_%04d.dat");
RooMCStudy *mc_ST = new RooMCStudy(ext_hpdf_ST,mass,Binned(kTRUE),Silence(kTRUE),FitOptions(ExternalConstraints(STgaussConstraint)));
mc_ST->generate(Nsamples,0,kFALSE,"data/toymc_ST_%04d.dat");
return;
*/
RooMCStudy *mcstudy = new RooMCStudy(model_M3, mass, FitModel(model_histpdf),Binned(kTRUE),Silence(kTRUE), Extended() ,
//FitOptions(Save(kTRUE),Minos(kTRUE),Extended()) );
FitOptions(Save(kTRUE),Minos(kTRUE),Extended(),ExternalConstraints(STgaussConstraint)));//RooArgList(fconstext,fconstext2)) )); //gaussian constraint
//mcstudyM3->generate(Nsamples,0,kFALSE,"toymc.dat");
//mcstudyM3->generateAndFit(Nsamples,0,kFALSE,"toymc.dat");
//TList dataList;
//for (int isample=0; isample<Nsamples; ++isample) dataList.Add( mcstudyM3->genData(isample));
// Fit
mcstudy->generateAndFit(Nsamples,0,kTRUE);
//mcstudy->fit(Nsamples, "data/toymc_%04d.dat");
gDirectory->Add(mcstudy) ;
// E x p l o r e r e s u l t s o f s t u d y
// ------------------------------------------------
// Make plots of the distributions of mean, the error on mean and the pull of mean
RooPlot* frame1 = mcstudy->plotParam(Ntt,Bins(40));
RooPlot* frame2 = mcstudy->plotError(Ntt,Bins(40)) ;
RooPlot* frame3 = mcstudy->plotPull(Ntt,Bins(40),FitGauss(kTRUE)) ;
RooPlot* frame1w = mcstudy->plotParam(Nbkg,Bins(40)) ;
RooPlot* frame2w = mcstudy->plotError(Nbkg,Bins(40)) ;
RooPlot* frame3w = mcstudy->plotPull(Nbkg,Bins(40),FitGauss(kTRUE)) ;
RooPlot* frame1st = mcstudy->plotParam(NST,Bins(40)) ;
RooPlot* frame2st = mcstudy->plotError(NST,Bins(40)) ;
//RooPlot* frame3st = mcstudy->plotPull(NST,Bins(40),FitGauss(kTRUE)) ;
// Plot distribution of minimized likelihood
RooPlot* frame4 = mcstudy->plotNLL(Bins(40)) ;
// Make some histograms from the parameter dataset
TH1* hh_cor_ttbar_w = mcstudy->fitParDataSet().createHistogram("hh",Ntt,YVar(Nbkg)) ;
// Access some of the saved fit results from individual toys
//TH2* corrHist000 = mcstudy->fitResult(0)->correlationHist("c000") ;
//TH2* corrHist127 = mcstudy->fitResult(127)->correlationHist("c127") ;
//TH2* corrHist953 = mcstudy->fitResult(953)->correlationHist("c953") ;
// Draw all plots on a canvas
gStyle->SetPalette(1) ;
gStyle->SetOptStat(0) ;
TCanvas* cv = new TCanvas("cv","cv",600,600) ;
hM3->SetFillColor(kRed);
hWjets->SetFillColor(kGreen);
hM3->Draw();
hWjets->Draw("same");
gPad->RedrawAxis();
TCanvas* cva = new TCanvas("cva","cva",1800,600) ;
cva->Divide(3);
cva->cd(1) ;
RooPlot *initialframe = mass.frame();
//initial->SetMaximum(10);
hpdf_ttbar.plotOn(initialframe,LineColor(kRed));
hpdf_wjetsFast.plotOn(initialframe,LineColor(kGreen));
hpdf_ST.plotOn(initialframe,LineColor(kYellow));
initialframe->Draw();
//initialframe->SetTitle();
cva->cd(2);
//retrieve data for only one PE
int Npe = 10;
RooPlot *genframe = mass.frame(Nbins);
RooDataSet *gendata = mcstudy->genData(Npe);
cout << " N events = " << gendata->numEntries() << endl;
gendata->plotOn(genframe);
//mcstudy->fitResult(Npe)->plotOn(genframe, model_histpdf);
genframe->Draw();
cva->cd(3);
RooPlot *genframe2 = mass.frame(Nbins);
mcstudy->fitResult(Npe)->Print("v");
gendata->plotOn(genframe2);
RooArgList arglist = mcstudy->fitResult(Npe)->floatParsFinal();
//cout << "name of argument:" << arglist[2].GetName() << endl;
//cout << "name of argument:" << arglist[1].GetName() << endl;
//cout << "name of argument:" << arglist[0].GetName() << endl;
RooAddPdf model_histpdf_fitted("modelfitted", "TTjets+Wjets", RooArgList(hpdf_ttbar,hpdf_wjetsFast,hpdf_ST),
RooArgList(arglist[2],arglist[1],arglist[0]) ) ;
model_histpdf_fitted.plotOn(genframe2,LineColor(kRed));
model_histpdf_fitted.plotOn(genframe2,Components(hpdf_wjetsFast),LineColor(kGreen));
model_histpdf_fitted.plotOn(genframe2,Components(hpdf_ST),LineColor(kYellow));
genframe2->Draw();
TCanvas* cvb = new TCanvas("cvb","cvb",1800,600) ;
cvb->Divide(3);
cvb->cd(1) ; frame1->Draw();
cvb->cd(2) ; frame2->Draw();
cvb->cd(3) ; frame3->Draw();
TCanvas* cvbb = new TCanvas("cvbb","cvbb",1800,600) ;
cvbb->Divide(3);
cvbb->cd(1) ; frame1w->Draw();
cvbb->cd(2) ; frame2w->Draw();
cvbb->cd(3) ; frame3w->Draw();
TCanvas* cvbbb = new TCanvas("cvbbb","cvbbb",1200,600) ;
cvbbb->Divide(2);
cvbbb->cd(1) ; frame1st->Draw();
cvbbb->cd(2) ; frame2st->Draw();
//cvbbb->cd(3) ; frame3st->Draw();
TCanvas* cvbc = new TCanvas("cvbc","cvbc",600,600) ;
TH2 *h2 = Ntt.createHistogram("Nttbar vs NWjets",Nbkg);
mcstudy->fitParDataSet().fillHistogram(h2,RooArgList(Ntt,Nbkg));
h2->Draw("box");
TCanvas* cvc = new TCanvas("cvc","cvc",600,600) ;
// Plot distribution of minimized likelihood
RooPlot* frame4 = mcstudy->plotNLL(Bins(40)) ;
frame4->Draw();
//return;//debuging
TCanvas* cvd = new TCanvas("cvd","cvd",600,600) ;
TCanvas* cve = new TCanvas("cve","cve",1200,600) ;
TCanvas* cvf = new TCanvas("cvf","cvf",600,600) ;
TH1F *hNgen = new TH1F("hNgen","Number of observed events",30,350,650);
hNgen->SetXTitle("Number of observed events");
TH1F *hNttresults = new TH1F("hNttresults","number of ttbar events",50,20,600);
TH1F *hNWresults = new TH1F("hNWresults","number of W events",50,-150,400);
TH1F *hNSTresults = new TH1F("hNSTresults","number of ttbar events",50,5,25);
bool gotone = false;
int Nfailed = 0;
for ( int i=0; i< Nsamples; i++)
{
RooFitResult *r = mcstudy->fitResult(i);
RooArgList list = r->floatParsFinal();
RooRealVar *rrv_nt = (RooRealVar*)list.at(2);
double nt = rrv_nt->getVal();
//double nte= rrv_nt->getError();
RooRealVar *rrv_nw = (RooRealVar*)list.at(1);
double nw = rrv_nw->getVal();
//double nwe= rrv_nw->getError();
RooRealVar *rrv_nst = (RooRealVar*)list.at(0);
double nst = rrv_nst->getVal();
hNttresults->Fill(nt);
hNWresults->Fill(nw);
hNSTresults->Fill(nst);
RooDataSet *adata = mcstudy->genData(i);
hNgen->Fill(adata->numEntries());
if ( r->numInvalidNLL() > 0 ) Nfailed++;
/*
if ( false ) {
cout << " sample # " << i << endl;
gotone = true;
r->Print("v");
cout << " invalidNLL = "<< r->numInvalidNLL() << endl;
cout << " N events = " << adata->numEntries() << endl;
RooAddPdf amodel("amodel", "TTjets+Wjets", RooArgList(hpdf_ttbar,hpdf_wjets,hpdf_ST),
RooArgList(list[2],list[1],list[0])) ;
RooPlot *d2 = new RooPlot(Ntt,NW,0,500,-200,200);
r->plotOn(d2,Ntt,NW,"ME12ABHV");
cvd->cd();
d2->Draw();
RooNLLVar nll("nll","nll", amodel, *adata, Extended() );//, Extended(), PrintEvalErrors(-1) );
RooMinuit myminuit(nll)
myminuit.migrad();
myminuit.hesse();
myminuit.minos();
//myminuit.Save()->Print("v");
cve->Divide(2);
RooPlot *nllframett = Ntt.frame(Bins(50),Range(100,600));//,Range(10,2000));
nll.plotOn(nllframett);//,ShiftToZero());
RooProfileLL pll_ntt("pll_ntt","pll_ntt",nll,Ntt);
pll_ntt.plotOn(nllframett,LineColor(kRed));
RooPlot *nllframeW = NW.frame(Bins(50),Range(0,250));//,Range(10,2000));
nll.plotOn(nllframeW);//,ShiftToZero());
RooProfileLL pll_nW("pll_nW","pll_nW",nll,NW);
pll_nW.plotOn(nllframeW,LineColor(kRed));
cve->cd(1);
nllframett->SetMaximum(2);
nllframett->Draw();
cve->cd(2);
nllframeW->SetMaximum(2);
nllframeW->Draw();
}
*/
}
TCanvas *tmpcv = new TCanvas("tmpcv","tmpcv",700,700);
cout << "\n ==================================" << endl;
cout << "gaussian fit of Nttbar fitted values: " << endl;
//hNttresults->Print("all");
hNttresults->Fit("gaus");
cout << "\n ==================================" << endl;
cout << "gaussian fit of NW fitted values: " << endl;
//hNWresults->Print("all");
hNWresults->Fit("gaus");
cout << "\n ==================================" << endl;
cout << "gaussian fit of NST fitted values: " << endl;
//hNSTresults->Print("all");
hNSTresults->Fit("gaus");
cout << "N failed fits = " << Nfailed << endl;
cvf->cd();
hNgen->Draw();
// Make RooMCStudy object available on command line after
// macro finishes
//gDirectory->Add(mcstudy) ;
}
void ztonunu1() {
// RooMsgService::instance().addStream(DEBUG,Topic(Tracing),ClassName("RooPoisson"),OutputFile("debug.log")) ;
float acc_mm_mean( 0.98 ) ; float acc_mm_err( 0.02 ) ;
float acc_ee_mean( 0.98 ) ; float acc_ee_err( 0.02 ) ;
float eff_mm_mean( 0.77 ) ; float eff_mm_err( 0.08 ) ;
float eff_ee_mean( 0.76 ) ; float eff_ee_err( 0.08 ) ;
RooRealVar* rv_Nsbee = new RooRealVar( "Nsbee" ,"Nsbee" , 0., 100. ) ;
RooRealVar* rv_Nsbmm = new RooRealVar( "Nsbmm" ,"Nsbmm" , 0., 100. ) ;
RooRealVar* rv_Nsigee = new RooRealVar( "Nsigee" ,"Nsigee" , 0., 100. ) ;
RooRealVar* rv_Nsigmm = new RooRealVar( "Nsigmm" ,"Nsigmm" , 0., 100. ) ;
rv_Nsbee->setVal( 5 ) ;
rv_Nsbmm->setVal( 3 ) ;
rv_Nsigee->setVal( 4 ) ;
rv_Nsigmm->setVal( 3 ) ;
RooRealVar* rv_mu_Znnsb = new RooRealVar( "mu_Znnsb" , "mu_Znnsb" , 0., 100. ) ;
RooRealVar* rv_mu_Znnsig = new RooRealVar( "mu_Znnsig" , "mu_Znnsig" , 0., 100. ) ;
rv_mu_Znnsb->setVal( 37 ) ; // starting value
rv_mu_Znnsig->setVal( 17. ) ; // starting value
RooRealVar* rv_bfRatio = new RooRealVar( "bfRatio", "bfRatio", 0., 10. ) ;
rv_bfRatio->setVal( 5.95 ) ;
rv_bfRatio->setConstant( kTRUE ) ;
RooRealVar* rv_acc_mm = new RooRealVar( "acc_mm", "acc_mm", 0.001, 1.000 ) ;
RooRealVar* rv_acc_ee = new RooRealVar( "acc_ee", "acc_ee", 0.001, 1.000 ) ;
RooRealVar* rv_eff_mm = new RooRealVar( "eff_mm", "eff_mm", 0.001, 1.000 ) ;
RooRealVar* rv_eff_ee = new RooRealVar( "eff_ee", "eff_ee", 0.001, 1.000 ) ;
rv_acc_mm->setVal( acc_mm_mean ) ;
rv_acc_ee->setVal( acc_ee_mean ) ;
rv_eff_mm->setVal( eff_mm_mean ) ;
rv_eff_ee->setVal( eff_ee_mean ) ;
RooRealVar* rv_lumi_ratio = new RooRealVar( "lumi_ratio", "lumi_ratio", 0., 10. ) ;
rv_lumi_ratio -> setVal( 686./869. ) ;
rv_lumi_ratio -> setConstant( kTRUE) ;
RooFormulaVar* rv_mu_Zeesb = new RooFormulaVar( "mu_Zeesb",
"mu_Znnsb * ( acc_ee * eff_ee / (bfRatio*lumi_ratio) )",
RooArgSet( *rv_mu_Znnsb, *rv_acc_ee, *rv_eff_ee, *rv_bfRatio, *rv_lumi_ratio ) ) ;
RooFormulaVar* rv_mu_Zmmsb = new RooFormulaVar( "mu_Zmmsb",
"mu_Znnsb * ( acc_mm * eff_mm / (bfRatio*lumi_ratio) )",
RooArgSet( *rv_mu_Znnsb, *rv_acc_mm, *rv_eff_mm, *rv_bfRatio, *rv_lumi_ratio ) ) ;
RooFormulaVar* rv_mu_Zeesig = new RooFormulaVar( "mu_Zeesig",
"mu_Znnsig * ( acc_ee * eff_ee / (bfRatio*lumi_ratio) )",
RooArgSet( *rv_mu_Znnsig, *rv_acc_ee, *rv_eff_ee, *rv_bfRatio, *rv_lumi_ratio ) ) ;
RooFormulaVar* rv_mu_Zmmsig = new RooFormulaVar( "mu_Zmmsig",
"mu_Znnsig * ( acc_mm * eff_mm / (bfRatio*lumi_ratio) )",
RooArgSet( *rv_mu_Znnsig, *rv_acc_mm, *rv_eff_mm, *rv_bfRatio, *rv_lumi_ratio ) ) ;
RooFormulaVar* rv_n_sbee = new RooFormulaVar( "n_sbee" , "mu_Zeesb" , RooArgSet( *rv_mu_Zeesb ) ) ;
RooFormulaVar* rv_n_sbmm = new RooFormulaVar( "n_sbmm" , "mu_Zmmsb" , RooArgSet( *rv_mu_Zmmsb ) ) ;
RooFormulaVar* rv_n_sigee = new RooFormulaVar( "n_sigee" , "mu_Zeesig" , RooArgSet( *rv_mu_Zeesig ) ) ;
RooFormulaVar* rv_n_sigmm = new RooFormulaVar( "n_sigmm" , "mu_Zmmsig" , RooArgSet( *rv_mu_Zmmsig ) ) ;
RooGaussian* pdf_acc_mm = new RooGaussian( "pdf_acc_mm", "Gaussian pdf for Z to mumu acceptance",
*rv_acc_mm, RooConst( acc_mm_mean ), RooConst( acc_mm_err ) ) ;
RooGaussian* pdf_acc_ee = new RooGaussian( "pdf_acc_ee", "Gaussian pdf for Z to ee acceptance",
*rv_acc_ee, RooConst( acc_ee_mean ), RooConst( acc_ee_err ) ) ;
RooGaussian* pdf_eff_mm = new RooGaussian( "pdf_eff_mm", "Gaussian pdf for Z to mumu efficiency",
*rv_eff_mm, RooConst( eff_mm_mean ), RooConst( eff_mm_err ) ) ;
RooGaussian* pdf_eff_ee = new RooGaussian( "pdf_eff_ee", "Gaussian pdf for Z to ee efficiency",
*rv_eff_ee, RooConst( eff_ee_mean ), RooConst( eff_ee_err ) ) ;
RooPoisson* pdf_Nsbee = new RooPoisson( "pdf_Nsbee" , "Nsb , Z to ee Poisson PDF", *rv_Nsbee , *rv_n_sbee ) ;
RooPoisson* pdf_Nsbmm = new RooPoisson( "pdf_Nsbmm" , "Nsb , Z to mm Poisson PDF", *rv_Nsbmm , *rv_n_sbmm ) ;
RooPoisson* pdf_Nsigee = new RooPoisson( "pdf_Nsigee" , "Nsig, Z to ee Poisson PDF", *rv_Nsigee , *rv_n_sigee ) ;
RooPoisson* pdf_Nsigmm = new RooPoisson( "pdf_Nsigmm" , "Nsig, Z to mm Poisson PDF", *rv_Nsigmm , *rv_n_sigmm ) ;
RooArgSet pdflist ;
pdflist.add( *pdf_acc_mm ) ;
pdflist.add( *pdf_acc_ee ) ;
pdflist.add( *pdf_eff_mm ) ;
pdflist.add( *pdf_eff_ee ) ;
pdflist.add( *pdf_Nsbee ) ;
pdflist.add( *pdf_Nsbmm ) ;
pdflist.add( *pdf_Nsigee ) ;
pdflist.add( *pdf_Nsigmm ) ;
RooProdPdf* znnLikelihood = new RooProdPdf( "znnLikelihood", "Z to nunu likelihood", pdflist ) ;
RooArgSet observedParametersList ;
observedParametersList.add( *rv_Nsbee ) ;
observedParametersList.add( *rv_Nsbmm ) ;
observedParametersList.add( *rv_Nsigee ) ;
observedParametersList.add( *rv_Nsigmm ) ;
RooDataSet* dsObserved = new RooDataSet( "ztonn_rds", "Z to nunu dataset", observedParametersList ) ;
dsObserved->add( observedParametersList ) ;
//// RooDataSet* dsObserved = znnLikelihood->generate( observedParametersList, 1) ;
RooWorkspace* znnWorkspace = new RooWorkspace("ztonn_ws") ;
znnWorkspace->import( *znnLikelihood ) ;
znnWorkspace->import( *dsObserved ) ;
znnWorkspace->Print() ;
dsObserved->printMultiline(cout, 1, kTRUE, "") ;
RooFitResult* fitResult = znnLikelihood->fitTo( *dsObserved, Verbose(true), Save(true) ) ;
printf("\n\n----- Constant parameters:\n") ;
RooArgList constPars = fitResult->constPars() ;
for ( int pi=0; pi<constPars.getSize(); pi++ ) {
constPars[pi].Print() ;
} // pi.
printf("\n\n----- Floating parameters:\n") ;
RooArgList floatPars = fitResult->floatParsFinal() ;
for ( int pi=0; pi<floatPars.getSize(); pi++ ) {
floatPars[pi].Print() ;
} // pi.
printf("\n\n") ;
ProfileLikelihoodCalculator plc_znn_sb( *dsObserved, *znnLikelihood, RooArgSet( *rv_mu_Znnsb ) ) ;
ProfileLikelihoodCalculator plc_znn_sig( *dsObserved, *znnLikelihood, RooArgSet( *rv_mu_Znnsig ) ) ;
plc_znn_sb.SetTestSize(0.32) ;
plc_znn_sig.SetTestSize(0.32) ;
ConfInterval* sb_znn_interval = plc_znn_sb.GetInterval() ;
float sbZnnLow = ((LikelihoodInterval*) sb_znn_interval)->LowerLimit(*rv_mu_Znnsb) ;
float sbZnnHigh = ((LikelihoodInterval*) sb_znn_interval)->UpperLimit(*rv_mu_Znnsb) ;
printf("\n\n znn SB interval %6.1f to %6.1f\n", sbZnnLow, sbZnnHigh ) ;
ConfInterval* sig_znn_interval = plc_znn_sig.GetInterval() ;
float sigZnnLow = ((LikelihoodInterval*) sig_znn_interval)->LowerLimit(*rv_mu_Znnsig) ;
float sigZnnHigh = ((LikelihoodInterval*) sig_znn_interval)->UpperLimit(*rv_mu_Znnsig) ;
printf("\n\n znn SIG interval %6.1f to %6.1f\n", sigZnnLow, sigZnnHigh ) ;
TCanvas* c_prof_sb = new TCanvas("c_prof_sb","SB Z to nunu profile") ;
LikelihoodIntervalPlot plot_znn_sb((LikelihoodInterval*)sb_znn_interval) ;
plot_znn_sb.Draw() ;
c_prof_sb->SaveAs("znn_sb_profile.png") ;
TCanvas* c_prof_sig = new TCanvas("c_prof_sig","sig Z to nunu profile") ;
LikelihoodIntervalPlot plot_znn_sig((LikelihoodInterval*)sig_znn_interval) ;
plot_znn_sig.Draw() ;
c_prof_sig->SaveAs("znn_sig_profile.png") ;
}
void fitDilMass(){
using namespace RooFit;
gROOT->SetStyle("Plain");
//declare variables
RooRealVar mll("mll", "dilepton mass", 0,100 ,"GeV");
RooRealVar edge("edge", "dilepton mass edge", 0,100 ,"GeV");
RooRealVar min("min", "min dilepton mass", 0,100 ,"GeV");
RooRealVar k("k", "constant", 0,100 ,"GeV");
RooRealVar mean("mean", "mean of mll resolution", 0,100 ,"GeV");
RooRealVar sigma("sigma", "sigma of mll resolution", 0,10 ,"GeV");
//set variables
mll.setBins(100);
edge.setVal(50.);
mean.setVal(0.);
sigma.setVal(2.);
min.setVal(10.);
min.setConstant();
k.setVal(1.);
mean.setConstant();
sigma.setConstant();
mll.setMin(0);
mll.setMax(100);
//get data
TFile* file = TFile::Open("LM0_dilmass.root");
TH1D* hist = static_cast<TH1D *>((file)->Get("dilmass"));
RooDataHist data("data","data histogram",RooArgSet(mll),hist);
//declare and make PDFs
RooGenericPdf tri("tri","( (mll < min && mll > 0) * k + (mll > min && mll < edge ) * (mll - min) + (mll > edge && mll < 200) * k)", RooArgList(mll , edge, min, k) );
RooGaussian gaus("gaus","Detector Gaussian",mll,mean,sigma);
RooNumConvPdf trigaus("trigaus","triangle + gaussian function",mll,tri,gaus);
trigaus.setConvolutionWindow(mean,sigma,25);
//do fit
RooFitResult *result = trigaus.fitTo( data , Save() , Minos(kFALSE) , SumW2Error(kFALSE));
//make plot
TCanvas *c1=new TCanvas("c1","",800,600);
c1->cd();
RooPlot* frame = mll.frame();
frame->SetXTitle("dilepton mass (GeV)");
frame->SetYTitle("");
frame->SetTitle("");
data.plotOn(frame);
tri.plotOn(frame , LineStyle(kDashed));
trigaus.plotOn( frame );
trigaus.paramOn( frame );
frame->Draw();
//frame->SetMinimum(-10);
//frame->SetMaximum(100);
int nfloatpars = result->floatParsFinal().getSize();
int ndf = 20 - nfloatpars;
float chi2 = frame->chiSquare(nfloatpars)*ndf;
float prob = TMath::Prob(chi2,ndf);
cout << endl << endl;
cout << "Fit Results-------------------------------------------" << endl;
cout << "chi2/ndf = " << chi2 << " / " << ndf << endl;
cout << "prob = " << prob << endl;
cout << "edge = " << edge.getVal() << " +/- " << edge.getError() << endl;
cout << "k = " << k.getVal() << " +/- " << k.getError() << endl;
cout << "------------------------------------------------------" << endl;
cout << endl << endl;
}
int KinZfitter::PerZ1Likelihood(double & l1, double & l2, double & lph1, double & lph2)
{
l1= 1.0; l2 = 1.0;
lph1 = 1.0; lph2 = 1.0;
if(debug_) cout<<"start Z1 refit"<<endl;
TLorentzVector Z1_1 = p4sZ1_[0]; TLorentzVector Z1_2 = p4sZ1_[1];
double RECOpT1 = Z1_1.Pt(); double RECOpT2 = Z1_2.Pt();
double pTerrZ1_1 = pTerrsZ1_[0]; double pTerrZ1_2 = pTerrsZ1_[1];
if(debug_)cout<<"pT1 "<<RECOpT1<<" pTerrZ1_1 "<<pTerrZ1_1<<endl;
if(debug_)cout<<"pT2 "<<RECOpT2<<" pTerrZ1_2 "<<pTerrZ1_2<<endl;
//////////////
TLorentzVector Z1_ph1, Z1_ph2;
double pTerrZ1_ph1, pTerrZ1_ph2;
double RECOpTph1, RECOpTph2;
TLorentzVector nullFourVector(0, 0, 0, 0);
Z1_ph1=nullFourVector; Z1_ph2=nullFourVector;
RECOpTph1 = 0; RECOpTph2 = 0;
pTerrZ1_ph1 = 0; pTerrZ1_ph2 = 0;
if(p4sZ1ph_.size()>=1){
Z1_ph1 = p4sZ1ph_[0]; pTerrZ1_ph1 = pTerrsZ1ph_[0];
RECOpTph1 = Z1_ph1.Pt();
if(debug_) cout<<"put in Z1 fsr photon 1 pT "<<RECOpTph1<<" pT err "<<pTerrZ1_ph1<<endl;
}
if(p4sZ1ph_.size()==2){
//if(debug_) cout<<"put in Z1 fsr photon 2"<<endl;
Z1_ph2 = p4sZ1ph_[1]; pTerrZ1_ph2 = pTerrsZ1ph_[1];
RECOpTph2 = Z1_ph2.Pt();
}
RooRealVar* pT1RECO = new RooRealVar("pT1RECO","pT1RECO", RECOpT1, 5, 500);
RooRealVar* pT2RECO = new RooRealVar("pT2RECO","pT2RECO", RECOpT2, 5, 500);
double RECOpT1min = max(5.0, RECOpT1-2*pTerrZ1_1);
double RECOpT2min = max(5.0, RECOpT2-2*pTerrZ1_2);
RooRealVar* pTph1RECO = new RooRealVar("pTph1RECO","pTph1RECO", RECOpTph1, 5, 500);
RooRealVar* pTph2RECO = new RooRealVar("pTph2RECO","pTph2RECO", RECOpTph2, 5, 500);
double RECOpTph1min = max(0.5, RECOpTph1-2*pTerrZ1_ph1);
double RECOpTph2min = max(0.5, RECOpTph2-2*pTerrZ1_ph2);
// observables pT1,2,ph1,ph2
RooRealVar* pT1 = new RooRealVar("pT1", "pT1FIT", RECOpT1, RECOpT1min, RECOpT1+2*pTerrZ1_1 );
RooRealVar* pT2 = new RooRealVar("pT2", "pT2FIT", RECOpT2, RECOpT2min, RECOpT2+2*pTerrZ1_2 );
RooRealVar* m1 = new RooRealVar("m1","m1", Z1_1.M());
RooRealVar* m2 = new RooRealVar("m2","m2", Z1_2.M());
if(debug_) cout<<"m1 "<<m1->getVal()<<" m2 "<<m2->getVal()<<endl;
double Vtheta1, Vphi1, Vtheta2, Vphi2;
Vtheta1 = (Z1_1).Theta(); Vtheta2 = (Z1_2).Theta();
Vphi1 = (Z1_1).Phi(); Vphi2 = (Z1_2).Phi();
RooRealVar* theta1 = new RooRealVar("theta1","theta1",Vtheta1);
RooRealVar* phi1 = new RooRealVar("phi1","phi1",Vphi1);
RooRealVar* theta2 = new RooRealVar("theta2","theta2",Vtheta2);
RooRealVar* phi2 = new RooRealVar("phi2","phi2",Vphi2);
// dot product to calculate (p1+p2+ph1+ph2).M()
RooFormulaVar E1("E1","TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1)))+@2*@2)",
RooArgList(*pT1,*theta1,*m1));
RooFormulaVar E2("E2","TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1)))+@2*@2)",
RooArgList(*pT2,*theta2,*m2));
if(debug_) cout<<"E1 "<<E1.getVal()<<"; E2 "<<E2.getVal()<<endl;
/////
RooRealVar* pTph1 = new RooRealVar("pTph1", "pTph1FIT", RECOpTph1, RECOpTph1min, RECOpTph1+2*pTerrZ1_ph1 );
RooRealVar* pTph2 = new RooRealVar("pTph2", "pTph2FIT", RECOpTph2, RECOpTph2min, RECOpTph2+2*pTerrZ1_ph2 );
double Vthetaph1, Vphiph1, Vthetaph2, Vphiph2;
Vthetaph1 = (Z1_ph1).Theta(); Vthetaph2 = (Z1_ph2).Theta();
Vphiph1 = (Z1_ph1).Phi(); Vphiph2 = (Z1_ph2).Phi();
RooRealVar* thetaph1 = new RooRealVar("thetaph1","thetaph1",Vthetaph1);
RooRealVar* phiph1 = new RooRealVar("phiph1","phiph1",Vphiph1);
RooRealVar* thetaph2 = new RooRealVar("thetaph2","thetaph2",Vthetaph2);
RooRealVar* phiph2 = new RooRealVar("phiph2","phi2",Vphiph2);
RooFormulaVar Eph1("Eph1","TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1))))",
RooArgList(*pTph1,*thetaph1));
RooFormulaVar Eph2("Eph2","TMath::Sqrt((@0*@0)/((TMath::Sin(@1))*(TMath::Sin(@1))))",
RooArgList(*pTph2,*thetaph2));
//// dot products of 4-vectors
// 3-vector DOT
RooFormulaVar* p1v3D2 = new RooFormulaVar("p1v3D2",
"@0*@1*( ((TMath::Cos(@2))*(TMath::Cos(@3)))/((TMath::Sin(@2))*(TMath::Sin(@3)))+(TMath::Cos(@4-@5)))",
RooArgList(*pT1,*pT2,*theta1,*theta2,*phi1,*phi2));
if(debug_) cout<<"p1 DOT p2 is "<<p1v3D2->getVal()<<endl;
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar p1D2("p1D2","@0*@1-@2",RooArgList(E1,E2,*p1v3D2));
//lep DOT fsrPhoton1
// 3-vector DOT
RooFormulaVar* p1v3Dph1 = new RooFormulaVar("p1v3Dph1",
"@0*@1*( (TMath::Cos(@2)*TMath::Cos(@3))/(TMath::Sin(@2)*TMath::Sin(@3))+TMath::Cos(@4-@5))",
RooArgList(*pT1,*pTph1,*theta1,*thetaph1,*phi1,*phiph1));
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar p1Dph1("p1Dph1","@0*@1-@2",RooArgList(E1,Eph1,*p1v3Dph1));
// 3-vector DOT
RooFormulaVar* p2v3Dph1 = new RooFormulaVar("p2v3Dph1",
"@0*@1*( (TMath::Cos(@2)*TMath::Cos(@3))/(TMath::Sin(@2)*TMath::Sin(@3))+TMath::Cos(@4-@5))",
RooArgList(*pT2,*pTph1,*theta2,*thetaph1,*phi2,*phiph1));
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar p2Dph1("p2Dph1","@0*@1-@2",RooArgList(E2,Eph1,*p2v3Dph1));
// lep DOT fsrPhoton2
// 3-vector DOT
RooFormulaVar* p1v3Dph2 = new RooFormulaVar("p1v3Dph2",
"@0*@1*( (TMath::Cos(@2)*TMath::Cos(@3))/(TMath::Sin(@2)*TMath::Sin(@3))+TMath::Cos(@4-@5))",
RooArgList(*pT1,*pTph2,*theta1,*thetaph2,*phi1,*phiph2));
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar p1Dph2("p1Dph2","@0*@1-@2",RooArgList(E1,Eph2,*p1v3Dph2));
// 3-vector DOT
RooFormulaVar* p2v3Dph2 = new RooFormulaVar("p2v3Dph2",
"@0*@1*( (TMath::Cos(@2)*TMath::Cos(@3))/(TMath::Sin(@2)*TMath::Sin(@3))+TMath::Cos(@4-@5))",
RooArgList(*pT2,*pTph2,*theta2,*thetaph2,*phi2,*phiph2));
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar p2Dph2("p2Dph2","@0*@1-@2",RooArgList(E2,Eph2,*p2v3Dph2));
// fsrPhoton1 DOT fsrPhoton2
// 3-vector DOT
RooFormulaVar* ph1v3Dph2 = new RooFormulaVar("ph1v3Dph2",
"@0*@1*( (TMath::Cos(@2)*TMath::Cos(@3))/(TMath::Sin(@2)*TMath::Sin(@3))+TMath::Cos(@4-@5))",
RooArgList(*pTph1,*pTph2,*thetaph1,*thetaph2,*phiph1,*phiph2));
// 4-vector DOT metric 1 -1 -1 -1
RooFormulaVar ph1Dph2("ph1Dph2","@0*@1-@2",RooArgList(Eph1,Eph2,*ph1v3Dph2));
// mZ1
RooFormulaVar* mZ1;
mZ1 = new RooFormulaVar("mZ1","TMath::Sqrt(2*@0+@1*@1+@2*@2)",RooArgList(p1D2,*m1,*m2));
if(p4sZ1ph_.size()==1)
mZ1 = new RooFormulaVar("mZ1","TMath::Sqrt(2*@0+2*@1+2*@2+@3*@3+@4*@4)",
RooArgList(p1D2, p1Dph1, p2Dph1, *m1,*m2));
if(p4sZ1ph_.size()==2)
mZ1 = new RooFormulaVar("mZ1","TMath::Sqrt(2*@0+2*@1+2*@2+2*@3+2*@4+2*@5+@6*@6+@7*@7)",
RooArgList(p1D2,p1Dph1,p2Dph1,p1Dph2,p2Dph2,ph1Dph2, *m1,*m2));
if(debug_) cout<<"mZ1 is "<<mZ1->getVal()<<endl;
// pTerrs, 1,2,ph1,ph2
RooRealVar sigmaZ1_1("sigmaZ1_1", "sigmaZ1_1", pTerrZ1_1);
RooRealVar sigmaZ1_2("sigmaZ1_2", "sigmaZ1_2", pTerrZ1_2);
RooRealVar sigmaZ1_ph1("sigmaZ1_ph1", "sigmaZ1_ph1", pTerrZ1_ph1);
RooRealVar sigmaZ1_ph2("sigmaZ1_ph2", "sigmaZ1_ph2", pTerrZ1_ph2);
// resolution for decay products
RooGaussian gauss1("gauss1","gaussian PDF", *pT1RECO, *pT1, sigmaZ1_1);
RooGaussian gauss2("gauss2","gaussian PDF", *pT2RECO, *pT2, sigmaZ1_2);
RooGaussian gaussph1("gaussph1","gaussian PDF", *pTph1RECO, *pTph1, sigmaZ1_ph1);
RooGaussian gaussph2("gaussph2","gaussian PDF", *pTph2RECO, *pTph2, sigmaZ1_ph2);
RooRealVar bwMean("bwMean", "m_{Z^{0}}", 91.187);
RooRealVar bwGamma("bwGamma", "#Gamma", 2.5);
RooRealVar sg("sg", "sg", sgVal_);
RooRealVar a("a", "a", aVal_);
RooRealVar n("n", "n", nVal_);
RooCBShape CB("CB","CB",*mZ1,bwMean,sg,a,n);
RooRealVar f("f","f", fVal_);
RooRealVar mean("mean","mean",meanVal_);
RooRealVar sigma("sigma","sigma",sigmaVal_);
RooRealVar f1("f1","f1",f1Val_);
RooGenericPdf RelBW("RelBW","1/( pow(mZ1*mZ1-bwMean*bwMean,2)+pow(mZ1,4)*pow(bwGamma/bwMean,2) )", RooArgSet(*mZ1,bwMean,bwGamma) );
RooAddPdf RelBWxCB("RelBWxCB","RelBWxCB", RelBW, CB, f);
RooGaussian gauss("gauss","gauss",*mZ1,mean,sigma);
RooAddPdf RelBWxCBxgauss("RelBWxCBxgauss","RelBWxCBxgauss", RelBWxCB, gauss, f1);
RooProdPdf *PDFRelBWxCBxgauss;
PDFRelBWxCBxgauss = new RooProdPdf("PDFRelBWxCBxgauss","PDFRelBWxCBxgauss",
RooArgList(gauss1, gauss2, RelBWxCBxgauss) );
if(p4sZ1ph_.size()==1)
PDFRelBWxCBxgauss = new RooProdPdf("PDFRelBWxCBxgauss","PDFRelBWxCBxgauss",
RooArgList(gauss1, gauss2, gaussph1, RelBWxCBxgauss) );
if(p4sZ1ph_.size()==2)
PDFRelBWxCBxgauss = new RooProdPdf("PDFRelBWxCBxgauss","PDFRelBWxCBxgauss",
RooArgList(gauss1, gauss2, gaussph1, gaussph2, RelBWxCBxgauss) );
// observable set
RooArgSet *rastmp;
rastmp = new RooArgSet(*pT1RECO,*pT2RECO);
if(p4sZ1ph_.size()==1)
rastmp = new RooArgSet(*pT1RECO,*pT2RECO,*pTph1RECO);
if(p4sZ1ph_.size()>=2)
rastmp = new RooArgSet(*pT1RECO,*pT2RECO,*pTph1RECO,*pTph2RECO);
RooDataSet* pTs = new RooDataSet("pTs","pTs", *rastmp);
pTs->add(*rastmp);
//RooAbsReal* nll;
//nll = PDFRelBWxCBxgauss->createNLL(*pTs);
//RooMinuit(*nll).migrad();
RooFitResult* r = PDFRelBWxCBxgauss->fitTo(*pTs,RooFit::Save(),RooFit::PrintLevel(-1));
const TMatrixDSym& covMatrix = r->covarianceMatrix();
const RooArgList& finalPars = r->floatParsFinal();
for (int i=0 ; i<finalPars.getSize(); i++){
TString name = TString(((RooRealVar*)finalPars.at(i))->GetName());
if(debug_) cout<<"name list of RooRealVar for covariance matrix "<<name<<endl;
}
int size = covMatrix.GetNcols();
//TMatrixDSym covMatrixTest_(size);
covMatrixZ1_.ResizeTo(size,size);
covMatrixZ1_ = covMatrix;
if(debug_) cout<<"save the covariance matrix"<<endl;
l1 = pT1->getVal()/RECOpT1; l2 = pT2->getVal()/RECOpT2;
double pTerrZ1REFIT1 = pT1->getError(); double pTerrZ1REFIT2 = pT2->getError();
pTerrsZ1REFIT_.push_back(pTerrZ1REFIT1);
pTerrsZ1REFIT_.push_back(pTerrZ1REFIT2);
if(p4sZ1ph_.size()>=1){
if(debug_) cout<<"set refit result for Z1 fsr photon 1"<<endl;
lph1 = pTph1->getVal()/RECOpTph1;
double pTerrZ1phREFIT1 = pTph1->getError();
if(debug_) cout<<"scale "<<lph1<<" pterr "<<pTerrZ1phREFIT1<<endl;
pTerrsZ1phREFIT_.push_back(pTerrZ1phREFIT1);
}
if(p4sZ1ph_.size()==2){
lph2 = pTph2->getVal()/RECOpTph2;
double pTerrZ1phREFIT2 = pTph2->getError();
pTerrsZ1phREFIT_.push_back(pTerrZ1phREFIT2);
}
//delete nll;
delete r;
delete mZ1;
delete pT1; delete pT2; delete pTph1; delete pTph2;
delete pT1RECO; delete pT2RECO; delete pTph1RECO; delete pTph2RECO;
delete ph1v3Dph2; delete p1v3Dph1; delete p2v3Dph1; delete p1v3Dph2; delete p2v3Dph2;
delete PDFRelBWxCBxgauss;
delete pTs;
delete rastmp;
if(debug_) cout<<"end Z1 refit"<<endl;
return 0;
}
int main(int argc, char* argv[]){
string fileName;
string fileNameZee;
string functionName;
string fileNameout;
int ncats;
int jcats;
int bins;
string outfilename;
bool is2011=false;
bool useDoubleCB=false;
bool verbose=false;
int mhLow;
int mhHigh;
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "Show help")
("infilename,i", po::value<string>(&fileName), "In file name")
("infilenameZee,I", po::value<string>(&fileNameZee), "In file name Zee")
("function,f", po::value<string>(&functionName), "Function to use")
("Outfilename,o", po::value<string>(&fileNameout), "Out file name")
("ncats,c", po::value<int>(&ncats)->default_value(5), "Number of categories")
("jcats,j", po::value<int>(&jcats)->default_value(0), "Start number of categories")
("mhLow,L", po::value<int>(&mhLow)->default_value(75), "Starting point for scan")
("mhHigh,H", po::value<int>(&mhHigh)->default_value(120), "End point for scan")
("bins,B", po::value<int>(&bins)->default_value(180), "Bins for the dataset")
("is2011", "Run 2011 config")
("useDoubleCB", "use double crystal ball function")
("verbose,v", "Run with more output")
;
po::variables_map vm;
po::store(po::parse_command_line(argc,argv,desc),vm);
po::notify(vm);
if (vm.count("help")) { cout << desc << endl; exit(1); }
if (vm.count("is2011")) is2011=true;
if (vm.count("useDoubleCB")) useDoubleCB=true;
if (vm.count("verbose")) verbose=true;
if (!verbose) {
RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR);
RooMsgService::instance().setSilentMode(true);
}
TFile *outputfile;
//RooWorkspace *outputws = new RooWorkspace("cms_hgg_workspace");
RooWorkspace *outputws;
outputfile = new TFile(fileNameout.c_str(),"RECREATE");
TFile *inFile = TFile::Open(fileName.c_str());
RooWorkspace *inWS = (RooWorkspace*)inFile->Get("cms_hgg_workspace");
outputws = (RooWorkspace*)inWS->Clone("cms_hgg_workspace");
vector<string> functionClasses;
functionClasses.push_back("Chebychev");
functionClasses.push_back("Bernstein");
functionClasses.push_back("Exponential");
functionClasses.push_back("PowerLaw");
functionClasses.push_back("Laurent");
map<string,string> namingMap;
namingMap.insert(pair<string,string>("Bernstein","pol"));
namingMap.insert(pair<string,string>("Exponential","exp"));
namingMap.insert(pair<string,string>("PowerLaw","pow"));
namingMap.insert(pair<string,string>("Laurent","lau"));
vector<pair<pair<string,int> ,pair<pair<int,int>, pair<float,float> > > > fabChoice;
int sqrts; string ext;
if (is2011) {
sqrts = 7;
ext = "7TeV";
}
else {
sqrts = 8;
ext = "8TeV";
fabChoice.push_back(pair<pair<string,int>, pair<pair<int,int>, pair<float,float> > >(make_pair("Bernstein",-3),make_pair(make_pair(5,1), make_pair(-11.0,11.0)))); //0
fabChoice.push_back(pair<pair<string,int>, pair<pair<int,int>, pair<float,float> > >(make_pair("Bernstein",-3),make_pair(make_pair(5,1), make_pair(-11.0,11.0)))); //1
fabChoice.push_back(pair<pair<string,int>, pair<pair<int,int>, pair<float,float> > >(make_pair("Chebychev",-3),make_pair(make_pair(5,1), make_pair(-11.0,11.0)))); //2
fabChoice.push_back(pair<pair<string,int>, pair<pair<int,int>, pair<float,float> > >(make_pair("Bernstein",-3),make_pair(make_pair(5,1), make_pair(-11.0,11.0)))); //3
}
// store results here
PdfModelBuilderFAN pdfsModel;
RooRealVar *mass = (RooRealVar*)inWS->var("CMS_hgg_mass");
mass->setRange(mhLow,mhHigh);
pdfsModel.setObsVar(mass);
mass->setBins(bins);
ofstream outfile("Zee_Yield.log");
cout<<"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Initialization Done +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
for (int cat=jcats; cat<ncats; cat++){
RooDataSet *dataFull = (RooDataSet*)inWS->data(Form("data_mass_cat%d",cat));
RooDataHist thisdataBinned(Form("roohist_data_mass_cat%d",cat),"data",*mass,*dataFull);
RooDataSet *data = (RooDataSet*)&thisdataBinned;
string funcType = fabChoice[cat].first.first;
float LaurentConstant = fabChoice[cat].first.second;
int orderOff = fabChoice[cat].second.first.first;
int orderBre = fabChoice[cat].second.first.second;
float bernDownBound = fabChoice[cat].second.second.first;
float bernUpBound = fabChoice[cat].second.second.second;
RooAbsPdf *pdfVoiFix; float voiMean=0.; float voiMeanErrorL=0.; float voiMeanErrorH=0.; float voiSigma=0.; float voiSigmaErrorL=0.; float voiSigmaErrorH=0.; float voiWidth=0; float voiWidthErrorL=0.; float voiWidthErrorH=0.; float voinCB1=0.; float voinCB1ErrorL=0.; float voinCB1ErrorH=0.; float voinCB2=0.; float voinCB2ErrorL=0.; float voinCB2ErrorH=0.; float voialphaCB1=0.; float voialphaCB2=0.; float ErrorRange=1.0;
if(orderBre != 0){
TFile *inFileZee = TFile::Open(fileNameZee.c_str());
RooWorkspace *inWS_Zee = (RooWorkspace*)inFileZee->Get("fTestVoi_Zee");
if(!useDoubleCB) pdfVoiFix = inWS_Zee->pdf(Form("ftest_Zee_Voi_%s_cat%d",ext.c_str(),cat));
else pdfVoiFix = inWS_Zee->pdf(Form("ftest_Zee_DCB_%s_cat%d",ext.c_str(),cat));
cout<<"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Get Zee Done +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
if(pdfVoiFix!=NULL){
if(!useDoubleCB){
((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_mean_p0",ext.c_str(),cat)))->setConstant(true);
voiMean = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_mean_p0",ext.c_str(),cat)))->getValV();
voiMeanErrorL = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_mean_p0",ext.c_str(),cat)))->getErrorLo();
voiMeanErrorH = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_mean_p0",ext.c_str(),cat)))->getErrorHi();
((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_sigma_p0",ext.c_str(),cat)))->setConstant(true);
voiSigma = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_sigma_p0",ext.c_str(),cat)))->getValV();
voiSigmaErrorL = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_sigma_p0",ext.c_str(),cat)))->getErrorLo();
voiSigmaErrorH = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_sigma_p0",ext.c_str(),cat)))->getErrorHi();
((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_width_p0",ext.c_str(),cat)))->setConstant(true);
voiWidth = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_width_p0",ext.c_str(),cat)))->getValV();
voiWidthErrorL = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_width_p0",ext.c_str(),cat)))->getErrorLo();
voiWidthErrorH = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_Voi_%s_cat%d_width_p0",ext.c_str(),cat)))->getErrorHi();
}else{
((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_mean_p0",ext.c_str(),cat)))->setConstant(true);
voiMean = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_mean_p0",ext.c_str(),cat)))->getValV();
voiMeanErrorL = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_mean_p0",ext.c_str(),cat)))->getErrorLo();
voiMeanErrorH = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_mean_p0",ext.c_str(),cat)))->getErrorHi();
((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_sigma_p0",ext.c_str(),cat)))->setConstant(true);
voiSigma = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_sigma_p0",ext.c_str(),cat)))->getValV();
voiSigmaErrorL = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_sigma_p0",ext.c_str(),cat)))->getErrorLo();
voiSigmaErrorH = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_sigma_p0",ext.c_str(),cat)))->getErrorHi();
((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_nCB1_p0",ext.c_str(),cat)))->setConstant(true);
voinCB1 = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_nCB1_p0",ext.c_str(),cat)))->getValV();
voinCB1ErrorL = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_nCB1_p0",ext.c_str(),cat)))->getErrorLo();
voinCB1ErrorH = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_nCB1_p0",ext.c_str(),cat)))->getErrorHi();
((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_nCB2_p0",ext.c_str(),cat)))->setConstant(true);
voinCB2 = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_nCB2_p0",ext.c_str(),cat)))->getValV();
voinCB2ErrorL = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_nCB2_p0",ext.c_str(),cat)))->getErrorLo();
voinCB2ErrorH = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_nCB2_p0",ext.c_str(),cat)))->getErrorHi();
((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_alphaCB1_p0",ext.c_str(),cat)))->setConstant(true);
voialphaCB1 = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_alphaCB1_p0",ext.c_str(),cat)))->getValV();
((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_alphaCB2_p0",ext.c_str(),cat)))->setConstant(true);
voialphaCB2 = ((RooRealVar*)inWS_Zee->allVars().find(Form("ftest_Zee_DCB_%s_cat%d_alphaCB2_p0",ext.c_str(),cat)))->getValV();
}
}
}
else{
pdfVoiFix = 0;
}
cout<<"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Get Zee Params Done +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
RooAbsPdf *bkgPdf;
if(orderBre == 0){
bkgPdf = getPdf(pdfsModel, funcType, orderOff, Form("pdf_data_pol_model_%dTeV_cat%d",sqrts,cat), LaurentConstant);
bkgPdf->SetName(Form("pdf_data_pol_model_%dTeV_cat%d",sqrts,cat));
}
else{
if(functionName == "Voi"){
if(!useDoubleCB){
bkgPdf = getPdfSumVoigtianFixNew(pdfsModel, funcType, orderOff, voiMean, voiMeanErrorL, voiMeanErrorH, voiSigma, voiSigmaErrorL, voiSigmaErrorH, voiWidth, voiWidthErrorL, voiWidthErrorH, ErrorRange, Form("pdf_data_pol_model_%dTeV_cat%d",sqrts,cat), LaurentConstant, bernDownBound, bernUpBound).first;
}else{
bkgPdf = getPdfSumVoigtianFixNewDouleCB(pdfsModel, funcType, orderOff, voiMean, voiMeanErrorL, voiMeanErrorH, voiSigma, voiSigmaErrorL, voiSigmaErrorH, voinCB1, voinCB1ErrorL, voinCB1ErrorH, voinCB2, voinCB2ErrorL, voinCB2ErrorH, voialphaCB1, voialphaCB2, ErrorRange, Form("pdf_data_pol_model_%dTeV_cat%d",sqrts,cat), LaurentConstant, bernDownBound, bernUpBound).first;
}
}
bkgPdf->SetName(Form("pdf_data_pol_model_%dTeV_cat%d",sqrts,cat));
}
RooArgSet *params = bkgPdf->getParameters(*data);
params->Print("v");
cout<<"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Prepare Final Pdf Done +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
RooFitResult *fitRes = bkgPdf->fitTo(*data,Save(true),Range(mhLow,mhHigh));
fitRes->floatParsInit().Print("v");
fitRes->floatParsFinal().Print("v");
if(voiMean != 0){
if(!useDoubleCB){
((RooRealVar*)params->find(Form("pdf_data_pol_model_8TeV_cat%d_Fvoimean",cat)))->setConstant(false);
((RooRealVar*)params->find(Form("pdf_data_pol_model_8TeV_cat%d_Fvoisigma",cat)))->setConstant(false);
((RooRealVar*)params->find(Form("pdf_data_pol_model_8TeV_cat%d_Fvoiwidth",cat)))->setConstant(false);
}else{
((RooRealVar*)params->find(Form("pdf_data_pol_model_8TeV_cat%d_Fdcbmean",cat)))->setConstant(false);
((RooRealVar*)params->find(Form("pdf_data_pol_model_8TeV_cat%d_Fdcbsigma",cat)))->setConstant(false);
((RooRealVar*)params->find(Form("pdf_data_pol_model_8TeV_cat%d_FdcbnCB1",cat)))->setConstant(false);
((RooRealVar*)params->find(Form("pdf_data_pol_model_8TeV_cat%d_FdcbnCB2",cat)))->setConstant(false);
}
params->Print("v");
float BernFrac = ((RooRealVar*)fitRes->floatParsFinal().find(Form("pdf_data_pol_model_8TeV_cat%d_frac_sum1",cat)))->getValV();
if(!useDoubleCB){
outfile << Form("cat %d ",cat) << data->sumEntries()*(1.0-BernFrac) << " Mean " << voiMean << " voiMeanErrorL " << voiMeanErrorL << " voiMeanErrorH "<< voiMeanErrorH << " voiSigma " << voiSigma << " voiSigmaErrorL " << voiSigmaErrorL << " voiSigmaErrorH " << voiSigmaErrorH << " voiWidth " << voiWidth << " voiWidthErrorL " << voiWidthErrorL << " voiWidthErrorH " << voiWidthErrorH << endl;
outfile << endl;
}else{
outfile << Form("cat %d ",cat) << data->sumEntries()*(1.0-BernFrac) << " Mean " << voiMean << " voiMeanErrorL " << voiMeanErrorL << " voiMeanErrorH "<< voiMeanErrorH << " voiSigma " << voiSigma << " voiSigmaErrorL " << voiSigmaErrorL << " voiSigmaErrorH " << voiSigmaErrorH << " nCB1 " << voinCB1 << " nCB1ErrorL " << voinCB1ErrorL << " nCB1ErrorH " << voinCB1ErrorH << " nCB2 " << voinCB2 << " nCB2ErrorL " << voinCB2ErrorL << " nCB2ErrorH " << voinCB2ErrorH << "bernfrac "<<BernFrac<< endl;
}
}
outputws->pdf(Form("pdf_data_pol_model_%dTeV_cat%d",sqrts,cat))->SetName(Form("pdf_data_pol_model_%dTeV_cat%d_OLD",sqrts,cat));
outputws->import(*bkgPdf);
//outputws->import(*data);
outputws->pdf(Form("pdf_data_pol_model_%dTeV_cat%d",sqrts,cat))->Print();
outputws->data(Form("data_mass_cat%d",cat))->Print("v");
outputws->data(Form("roohist_data_mass_cat%d",cat))->Print("v");
}
outputfile->cd();
outputws->Write();
outputfile->Close();
}
