void voigtian(RooDataSet *dataset, RooDataSet *dataset2, RooRealVar &variable, RooPlot *fitFrame, RooBinning b, double rangeMin, double rangeMax, vector <double> &fitParameters)
{
RooRealVar mean("mean","mean",0.0,-0.1,0.1);
RooRealVar sigma("sigma","sigma",0.5,0.0,1.0);
RooRealVar width("width","width",0.5,0.0,1.0);
RooVoigtian * pdf = new RooVoigtian("pdf","Voigtian",variable,mean,sigma,width);
dataset->plotOn(fitFrame,Name("myhist"),Binning(b),DataError(RooAbsData::SumW2));
RooFitResult * res = pdf->fitTo(*dataset, Range(rangeMin, rangeMax),Save(),SumW2Error(kTRUE));
res->Print();
//minNll = res->minNll();
pdf->plotOn(fitFrame,Name("mycurve"));
fitParameters.push_back(3); // nb of fit parameters
fitParameters.push_back(mean.getVal());
fitParameters.push_back(mean.getError());
fitParameters.push_back(sigma.getVal());
fitParameters.push_back(sigma.getError());
fitParameters.push_back(width.getVal());
fitParameters.push_back(width.getError());
}
void rf314_paramfitrange()
{
// D e f i n e o b s e r v a b l e s a n d d e c a y p d f
// ---------------------------------------------------------------
// Declare observables
RooRealVar t("t","t",0,5) ;
RooRealVar tmin("tmin","tmin",0,0,5) ;
// Make parameterized range in t : [tmin,5]
t.setRange(tmin,RooConst(t.getMax())) ;
// Make pdf
RooRealVar tau("tau","tau",-1.54,-10,-0.1) ;
RooExponential model("model","model",t,tau) ;
// C r e a t e i n p u t d a t a
// ------------------------------------
// Generate complete dataset without acceptance cuts (for reference)
RooDataSet* dall = model.generate(t,10000) ;
// Generate a (fake) prototype dataset for acceptance limit values
RooDataSet* tmp = RooGaussian("gmin","gmin",tmin,RooConst(0),RooConst(0.5)).generate(tmin,5000) ;
// Generate dataset with t values that observe (t>tmin)
RooDataSet* dacc = model.generate(t,ProtoData(*tmp)) ;
// F i t p d f t o d a t a i n a c c e p t a n c e r e g i o n
// -----------------------------------------------------------------------
RooFitResult* r = model.fitTo(*dacc,Save()) ;
// P l o t f i t t e d p d f o n f u l l a n d a c c e p t e d d a t a
// ---------------------------------------------------------------------------------
// Make plot frame, add datasets and overlay model
RooPlot* frame = t.frame(Title("Fit to data with per-event acceptance")) ;
dall->plotOn(frame,MarkerColor(kRed),LineColor(kRed)) ;
model.plotOn(frame) ;
dacc->plotOn(frame) ;
// Print fit results to demonstrate absence of bias
r->Print("v") ;
new TCanvas("rf314_paramranges","rf314_paramranges",600,600) ;
gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.6) ; frame->Draw() ;
return ;
}
//_________________________________________________
void TestJeffreysGaussSigma(){
// this one is VERY sensitive
// if the Gaussian is narrow ~ range(x)/nbins(x) then the peak isn't resolved
// and you get really bizzare shapes
// if the Gaussian is too wide range(x) ~ sigma then PDF gets renormalized
// and the PDF falls off too fast at high sigma
RooWorkspace w("w");
w.factory("Gaussian::g(x[0,-20,20],mu[0,-5,5],sigma[1,1,5])");
w.factory("n[100,.1,2000]");
w.factory("ExtendPdf::p(g,n)");
// w.var("sigma")->setConstant();
w.var("mu")->setConstant();
w.var("n")->setConstant();
w.var("x")->setBins(301);
RooDataHist* asimov = w.pdf("p")->generateBinned(*w.var("x"),ExpectedData());
RooFitResult* res = w.pdf("p")->fitTo(*asimov,Save(),SumW2Error(kTRUE));
asimov->Print();
res->Print();
TMatrixDSym cov = res->covarianceMatrix();
cout << "variance = " << (cov.Determinant()) << endl;
cout << "stdev = " << sqrt(cov.Determinant()) << endl;
cov.Invert();
cout << "jeffreys = " << sqrt(cov.Determinant()) << endl;
// w.defineSet("poi","mu,sigma");
//w.defineSet("poi","mu,sigma,n");
w.defineSet("poi","sigma");
w.defineSet("obs","x");
RooJeffreysPrior pi("jeffreys","jeffreys",*w.pdf("p"),*w.set("poi"),*w.set("obs"));
// pi.specialIntegratorConfig(kTRUE)->method1D().setLabel("RooAdaptiveGaussKronrodIntegrator1D") ;
pi.specialIntegratorConfig(kTRUE)->getConfigSection("RooIntegrator1D").setRealValue("maxSteps",3);
const RooArgSet* temp = w.set("poi");
pi.getParameters(*temp)->Print();
// return;
// return;
RooGenericPdf* test = new RooGenericPdf("test","test","sqrt(2.)/sigma",*w.set("poi"));
TCanvas* c1 = new TCanvas;
RooPlot* plot = w.var("sigma")->frame();
pi.plotOn(plot);
test->plotOn(plot,LineColor(kRed),LineStyle(kDotted));
plot->Draw();
}
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
void JeffreysPriorDemo(){
RooWorkspace w("w");
w.factory("Uniform::u(x[0,1])");
w.factory("mu[100,1,200]");
w.factory("ExtendPdf::p(u,mu)");
// w.factory("Poisson::pois(n[0,inf],mu)");
RooDataHist* asimov = w.pdf("p")->generateBinned(*w.var("x"),ExpectedData());
// RooDataHist* asimov2 = w.pdf("pois")->generateBinned(*w.var("n"),ExpectedData());
RooFitResult* res = w.pdf("p")->fitTo(*asimov,Save(),SumW2Error(kTRUE));
asimov->Print();
res->Print();
TMatrixDSym cov = res->covarianceMatrix();
cout << "variance = " << (cov.Determinant()) << endl;
cout << "stdev = " << sqrt(cov.Determinant()) << endl;
cov.Invert();
cout << "jeffreys = " << sqrt(cov.Determinant()) << endl;
w.defineSet("poi","mu");
w.defineSet("obs","x");
// w.defineSet("obs2","n");
RooJeffreysPrior pi("jeffreys","jeffreys",*w.pdf("p"),*w.set("poi"),*w.set("obs"));
// pi.specialIntegratorConfig(kTRUE)->method1D().setLabel("RooAdaptiveGaussKronrodIntegrator1D") ;
// pi.specialIntegratorConfig(kTRUE)->getConfigSection("RooIntegrator1D").setRealValue("maxSteps",10);
// JeffreysPrior pi2("jeffreys2","jeffreys",*w.pdf("pois"),*w.set("poi"),*w.set("obs2"));
// return;
RooGenericPdf* test = new RooGenericPdf("test","test","1./sqrt(mu)",*w.set("poi"));
TCanvas* c1 = new TCanvas;
RooPlot* plot = w.var("mu")->frame();
// pi.plotOn(plot, Normalization(1,RooAbsReal::Raw),Precision(.1));
pi.plotOn(plot);
// pi2.plotOn(plot,LineColor(kGreen),LineStyle(kDotted));
test->plotOn(plot,LineColor(kRed));
plot->Draw();
}
//_________________________________________________
void TestJeffreysGaussMean(){
RooWorkspace w("w");
w.factory("Gaussian::g(x[0,-20,20],mu[0,-5,5],sigma[1,0,10])");
w.factory("n[10,.1,200]");
w.factory("ExtendPdf::p(g,n)");
w.var("sigma")->setConstant();
w.var("n")->setConstant();
RooDataHist* asimov = w.pdf("p")->generateBinned(*w.var("x"),ExpectedData());
RooFitResult* res = w.pdf("p")->fitTo(*asimov,Save(),SumW2Error(kTRUE));
asimov->Print();
res->Print();
TMatrixDSym cov = res->covarianceMatrix();
cout << "variance = " << (cov.Determinant()) << endl;
cout << "stdev = " << sqrt(cov.Determinant()) << endl;
cov.Invert();
cout << "jeffreys = " << sqrt(cov.Determinant()) << endl;
// w.defineSet("poi","mu,sigma");
w.defineSet("poi","mu");
w.defineSet("obs","x");
RooJeffreysPrior pi("jeffreys","jeffreys",*w.pdf("p"),*w.set("poi"),*w.set("obs"));
// pi.specialIntegratorConfig(kTRUE)->method1D().setLabel("RooAdaptiveGaussKronrodIntegrator1D") ;
// pi.specialIntegratorConfig(kTRUE)->getConfigSection("RooIntegrator1D").setRealValue("maxSteps",3);
const RooArgSet* temp = w.set("poi");
pi.getParameters(*temp)->Print();
// return;
RooGenericPdf* test = new RooGenericPdf("test","test","1",*w.set("poi"));
TCanvas* c1 = new TCanvas;
RooPlot* plot = w.var("mu")->frame();
pi.plotOn(plot);
test->plotOn(plot,LineColor(kRed),LineStyle(kDotted));
plot->Draw();
}
RooFitResult* fitter_Zee(TH1D *hist){
RooRealVar Zmassvar("Zmassvar","Zmassvar", 82, 100);
RooDataHist *datahist = new RooDataHist("data","Z Mass",Zmassvar,hist);
RooPlot *Zmassvarframe = Zmassvar.frame(Name("Zmassvarframe"),Title(hist->GetTitle())) ;
datahist->plotOn(Zmassvarframe);
RooRealVar alpha ("alpha" , "alpha" , 0.005,0.001,0.1);
RooRealVar n ("n" , "n" , 1,0.001,10);
RooRealVar cbmean ("cbmean" , "cbmean" , 1, 0.8, 1.2);
RooRealVar cbsigma("cbsigma", "cbsigma" , 0.01, 0.001, 0.2);
RooRealVar bwmean("bwmean","bwmean",91,85,95);
RooRealVar bwsigma("bwsigma","bwsigma",3,2,4);
RooRealVar expoconst("expoconst","expoconst",-0.1,-0.5,0);
RooCBShape cball ("cball" , "crystal ball" , Zmassvar, cbmean, cbsigma, alpha, n);
RooBreitWigner bw("bw","breit wigner",Zmassvar,bwmean,bwsigma);
RooFFTConvPdf cballXbw("cballXbw","cball (X) bw",Zmassvar,bw,cball);
RooExponential expo("expo", "exponential", Zmassvar, expoconst);
RooRealVar frac("frac","frac",0.1,0.001,0.2);
RooAddPdf Zshapemodel("Zshapemodel","expo + cball (X) bw",RooArgList(expo,cballXbw),frac);
RooFitResult *fitres =Zshapemodel.fitTo(*datahist,Range(82,100),Save());
Zshapemodel.plotOn(Zmassvarframe,LineColor(kBlue));
Zmassvarframe->Draw();
fitres->Print();
return fitres;
};
///
/// Test PDF implementation.
/// Performs a fit to the minimum.
///
bool PDF_Abs::test()
{
bool quiet = false;
if(quiet) RooMsgService::instance().setGlobalKillBelow(ERROR);
fixParameters(observables);
floatParameters(parameters);
setLimit(parameters, "free");
RooFormulaVar ll("ll", "ll", "-2*log(@0)", RooArgSet(*pdf));
RooMinuit m(ll);
if(quiet) m.setPrintLevel(-2);
m.setNoWarn();
m.setLogFile("/dev/zero");
m.setErrorLevel(1.0);
m.setStrategy(2);
// m.setProfile(1);
m.migrad();
RooFitResult *f = m.save();
bool status = !(f->edm()<1 && f->status()==0);
if(!quiet) f->Print("v");
delete f;
if(quiet) RooMsgService::instance().setGlobalKillBelow(INFO);
if(!quiet) cout << "pdf->getVal() = " << pdf->getVal() << endl;
return status;
}
void SHyFT::fit(bool verbose)
{
if ( verbose ) cout << "Fitting" << endl;
RooArgSet nllset;
for(unsigned int i=0;i<bins_.size();++i) {
nllset.add(*bins_[i]->nll());
}
RooAddition nllsum("nllsum","nllsum",nllset);
RooMinuit m(nllsum);
if ( verbose ) m.setVerbose(kTRUE);
else {
m.setVerbose(kFALSE);
m.setPrintLevel(-1);
}
m.migrad();
m.hesse();
// m.minos();
if ( verbose ) {
RooFitResult * f = m.save();
f->Print("v");
}
}
///v1 using unbinnned fit
//input data text file
void FitTagAndProbev1(char *datafile_pass, char *datafile_fail, char *mcRootFile, char *mcPassHist, char *mcFailHist, float xminFit, float xmaxFit, bool SetPassBkgZero,bool SetFailBkgZero){
gROOT->cd();
gROOT->Reset();
gSystem->Load("libRooFit") ;
gSystem->Load("libRooFitCore") ;
RooRealVar* rooMass_ = new RooRealVar("Mass","m_{#mu#mu}",xminFit, xmaxFit, "GeV/c^{2}");
RooRealVar Mass = *rooMass_;
// Make the category variable that defines the two fits,
// namely whether the probe passes or fails the eff criteria.
RooCategory sample("sample","") ;
sample.defineType("Pass", 1) ;
sample.defineType("Fail", 2) ;
///////// convert Histograms into RooDataHists
//RooDataHist* data_pass = new RooDataHist("data_pass","data_pass",
//RooArgList(Mass), hist_pass);
RooDataSet *data_pass = RooDataSet::read(datafile_pass,RooArgSet(Mass));
//RooDataHist* data_fail = new RooDataHist("data_fail","data_fail",
//RooArgList(Mass), hist_fail);
RooDataSet *data_fail = RooDataSet::read(datafile_fail,RooArgSet(Mass));
cout<<data_pass->sumEntries()<<" " <<data_fail->sumEntries()<<endl;
// RooDataHist* data = new RooDataHist( "fitData","fitData",
// RooArgList(Mass),RooFit::Index(sample),
// RooFit::Import("Pass",*hist_pass), RooFit::Import("Fail",*hist_fail) );
RooDataSet* data = new RooDataSet( "fitData","fitData",RooArgList(Mass),RooFit::Index(sample),RooFit::Import("Pass",*data_pass),RooFit::Import("Fail",*data_fail) );
// Signal pdf
//TFile *Zeelineshape_file = new TFile("res/testTagProbe.dm2.dflag2.mT1.root","read");
// TFile *Zeelineshape_file = new TFile("res/testTagProbe.dm2.dflag2.mT1.cha1.mt30.root","read");
//res/testTagProbe.dm2.dflag2.mT1.cha1.mt30.root
//TFile *Zeelineshape_file = new TFile("res/testTagProbe.dm2.dflag3.mT1.cha0.mt-1.pu1.root","read");
TFile *Zeelineshape_file = new TFile(mcRootFile,"read");
TH1F *th1 = (TH1F*)Zeelineshape_file->Get(mcPassHist);
// ///int nbins = th1->GetNbinsX();
// int nbins = int( (xmaxFit - xminFit+0.1) / th1->GetBinWidth(1));
// int rebin = 2;
// nbins = nbins/ rebin;
// cout<<"nbins: "<< nbins <<endl;
// th1->Rebin(rebin);
int nbins = 60;
RooDataHist* rdh = new RooDataHist("rdh","", Mass, th1);
TH1 *th1f = (TH1F*)Zeelineshape_file->Get(mcFailHist);
RooDataHist* rdhf = new RooDataHist("rdh","", Mass, th1f);
const char *passHistName = th1->GetName();
const char *failHistName = th1f->GetName();
const char *passHistTitle = th1->GetTitle();
const char *failHistTitle = th1->GetTitle();
float xlowMC = th1->GetXaxis()->GetXmin();
float xmaxMC = th1->GetXaxis()->GetXmax();
if( xminFit < xlowMC || xmaxFit > xmaxMC ){
cout<<"FitRangeNotMC "<< xlowMC <<"to"<< xmaxMC <<" MC "<<endl;
return;
}
int startbin = int((xminFit-xlowMC+0.001)/th1->GetBinWidth(1)) + 1;
int endbin = int((xmaxFit-xlowMC+0.001)/th1->GetBinWidth(1));
float passMC = th1->Integral(startbin,endbin);
float allMC = th1->Integral(startbin,endbin) + th1f->Integral(startbin,endbin);
float effTP_MC = passMC / allMC;
float effTP_MCerr = sqrt( effTP_MC * (1- effTP_MC)/ allMC);
// float effTP_MC = th1->Integral() / ( th1->Integral() + th1f->Integral());
//RooRealVar* rooMass1_ = new RooRealVar("Mass","m_{#mu#mu}",xminFit, xmaxFit, "GeV/c^{2}");
//RooRealVar Mass1 = *rooMass1_;
// RooRealVar* massShift = new RooRealVar("massShift","massShift",0.,-2,2);
//RooFormulaVar* rooMass1_ = new RooFormulaVar("Mass1", "(1-massShift)*Mass", RooArgList(*massShift,Mass));
//RooFormulaVar Mass1 = *rooMass1_;
RooHistPdf* signalShapePdfPass = new RooHistPdf("signalShapePdf", "",
RooArgSet(Mass), *rdh,1);
RooHistPdf* signalShapePdfFail = new RooHistPdf("signalShapePdf", "",
RooArgSet(Mass), *rdhf,1);
RooRealVar cbBias ("#Deltam_{CB}", "CB Bias", 0.05, -2, 2,"GeV/c^{2}");
RooRealVar cbSigma("#sigma_{CB}","CB Width", 1.38, 0.01, 10.0,"GeV/c^{2}");
RooRealVar cbCut ("a_{CB}","CB Cut", 1.5, 0.1, 2.0);
RooRealVar cbPower("n_{CB}","CB Power", 1.3, 0.1, 20.0);
RooRealVar bwMean("m_{Z}","BW Mean", 91.1876, "GeV/c^{2}");
RooRealVar bwWidth("#Gamma_{Z}", "BW Width", 2.4952, "GeV/c^{2}");
RooBreitWigner bw("bw", "bw", Mass, bwMean, bwWidth);
RooCBShape cball("cball", "A Crystal Ball Lineshape", Mass, cbBias, cbSigma, cbCut, cbPower);
RooFFTConvPdf BWxCB("BWxCB","bw (X) crystall ball", Mass, bw, cball);
// Background pass PDF
RooRealVar* bkgShape = new RooRealVar("bkgShape","bkgShape",-0.2,-10.,0.);
if(SetPassBkgZero){
bkgShape = new RooRealVar("bkgShape","bkgShape",0.,0.,0.);
}
RooExponential* bkgShapePdf = new RooExponential("bkgShapePdf","bkgShapePdf",Mass, *bkgShape);
// Background fail PDF
RooRealVar* bkgShapef = new RooRealVar("bkgShapef","bkgShape",-0.2,-10.,0.);
if(SetFailBkgZero){
bkgShapef = new RooRealVar("bkgShapef","bkgShape",0.,0.,0.);
}
RooExponential* bkgShapePdff = new RooExponential("bkgShapePdff","bkgShapePdff",Mass, *bkgShapef);
//RooGenericPdf* bkgShapePdff = new RooGenericPdf("bkgShapePdff","bkgShapePdff","pow(Mass,bkgShapef)",RooArgSet(Mass, *bkgShapef));
// Now define some efficiency/yield variables
RooRealVar* numSignal = new RooRealVar("numSignal","numSignal", 100, 0.0, 1000000.0);
RooRealVar* eff = new RooRealVar("eff","eff", 0.9, 0.2, 1.0);
RooFormulaVar* nSigPass = new RooFormulaVar("nSigPass", "eff*numSignal", RooArgList(*eff,*numSignal));
RooFormulaVar* nSigFail = new RooFormulaVar("nSigFail", "(1.0-eff)*numSignal", RooArgList(*eff,*numSignal));
RooRealVar* nBkgPass = new RooRealVar("nBkgPass","nBkgPass", 100, 0.0, 10000000);
if(SetPassBkgZero){
nBkgPass = new RooRealVar("nBkgPass","nBkgPass", 0., 0., 0.);
}
RooRealVar* nBkgFail = new RooRealVar("nBkgFail","nBkgFail", 100, 0.0, 10000000);
if(SetFailBkgZero){
nBkgFail = new RooRealVar("nBkgFail","nBkgFail", 0.,0.,0.);
}
RooArgList componentsPass(*signalShapePdfPass,*bkgShapePdf);
RooArgList yieldsPass(*nSigPass, *nBkgPass);
RooArgList componentsFail(*signalShapePdfFail,*bkgShapePdff);
// RooArgList componentsFail(BWxCB,*bkgShapePdff);
RooArgList yieldsFail(*nSigFail, *nBkgFail);
RooAddPdf pdfPass("pdfPass","extended sum pdf", componentsPass, yieldsPass);
RooAddPdf pdfFail("pdfFail","extended sum pdf", componentsFail, yieldsFail);
// The total simultaneous fit ...
RooSimultaneous totalPdf("totalPdf","totalPdf", sample);
totalPdf.addPdf(pdfPass,"Pass");
totalPdf.Print();
totalPdf.addPdf(pdfFail,"Fail");
totalPdf.Print();
ifstream readinfail(datafile_fail,ios::in);
float mm;
int ndataFailPeak = 0;
while(readinfail.good()){
if( readinfail.eof()) break;
readinfail>>mm;
if( mm> 80 && mm <100){
ndataFailPeak ++;
}
}
// ********* Do the Actual Fit ********** //
RooFitResult *fitResult = totalPdf.fitTo(*data,RooFit::Save(true),
RooFit::Extended(true), RooFit::PrintLevel(-1));
fitResult->Print("v");
double numerator = nSigPass->getVal();
double nfails = nSigFail->getVal();
double denominator = numerator + nfails;
cout<<"num/den: "<< numerator <<" "<< denominator <<endl;
RooAbsData::ErrorType errorType = RooAbsData::Poisson;
TCanvas *can0 = new TCanvas("can0","c000",200,10,550,500);
setTCanvasNicev1(can0);
//RooPlot* frame1 = Mass.frame();
RooPlot* frame1 = Mass.frame(Range(xminFit,xmaxFit),Bins(nbins));
frame1->SetMinimum(0);
data_pass->plotOn(frame1,RooFit::DataError(errorType));
pdfPass.plotOn(frame1,RooFit::ProjWData(*data_pass),
RooFit::Components(*bkgShapePdf),RooFit::LineColor(kRed));
pdfPass.plotOn(frame1,RooFit::ProjWData(*data_pass));
frame1->Draw("e0");
char *filename = new char[1000];
sprintf(filename,"Probe Pass %s",passHistTitle);
TLatex l;
l.SetNDC();
l.SetTextSize(0.04);
l.SetTextColor(1);
l.DrawLatex(0.2,0.9,filename);
double nsig = numSignal->getVal();
double nErr = numSignal->getError();
double e = eff->getVal();
double eErr = eff->getError();
double corr = fitResult->correlation(*eff, *numSignal);
double err = ErrorInProduct(nsig, nErr, e, eErr, corr);
sprintf(filename, "N_{s} = %.2f #pm %.2f", nSigPass->getVal(), err);
l.DrawLatex(0.62,0.8,filename);
sprintf(filename, "N_{b} = %.2f #pm %.2f", nBkgPass->getVal(), nBkgPass->getError());
l.DrawLatex(0.62,0.75,filename);
sprintf(filename, "#epsilon^{Data}_{s} = %4.3f #pm %4.3f", eff->getVal(), eff->getError());
l.DrawLatex(0.62,0.7,filename);
sprintf(filename, "#epsilon^{MC}_{s} = %4.3f", effTP_MC);
l.DrawLatex(0.62,0.65,filename);
sprintf(filename,"resTP/hhu_probepass_%s.gif",passHistName);
can0->Print(filename);
sprintf(filename,"resTP/hhu_probepass_%s.pdf",passHistName);
can0->Print(filename);
//probel fail
TCanvas *can1 = new TCanvas("can1","c001",200,10,550,500);
setTCanvasNicev1(can1);
//RooPlot* frame1f = Mass.frame();
//RooPlot* frame1f = Mass.frame(Range(xminFit,xmaxFit),Bins(nbins));
RooPlot* frame1f = Mass.frame(Range(xminFit,xmaxFit),Bins(30));
frame1f->SetMinimum(0);
data_fail->plotOn(frame1f,RooFit::DataError(errorType));
pdfFail.plotOn(frame1f,RooFit::ProjWData(*data_fail),
RooFit::Components(*bkgShapePdff),RooFit::LineColor(kRed));
pdfFail.plotOn(frame1f,RooFit::ProjWData(*data_fail));
frame1f->Draw("e0");
sprintf(filename,"Probe Fail %s", failHistTitle);
l.DrawLatex(0.2,0.9,filename);
nsig = numSignal->getVal();
nErr = numSignal->getError();
e = 1-eff->getVal();
eErr = eff->getError();
corr = fitResult->correlation(*eff, *numSignal);
err = ErrorInProduct(nsig, nErr, e, eErr, corr);
sprintf(filename, "N_{s} = %.2f #pm %.2f", nSigFail->getVal(), err);
l.DrawLatex(0.6,0.8,filename);
sprintf(filename, "N_{b} = %.2f #pm %.2f", nBkgFail->getVal(), nBkgFail->getError());
l.DrawLatex(0.6,0.75,filename);
sprintf(filename, "#epsilon^{Data}_{s} = %3.3f #pm %3.3f", eff->getVal(), eff->getError());
//l.DrawLatex(0.65,0.6,filename);
sprintf(filename, "#epsilon^{MC}_{s} = %3.3f", effTP_MC);
//l.DrawLatex(0.6,0.5,filename);
sprintf(filename,"resTP/hhu_probefail_%s.pdf",failHistName);
can1->Print(filename);
sprintf(filename,"resTP/hhu_probefail_%s.gif",failHistName);
can1->Print(filename);
cout<<"effMC: "<< effTP_MC <<" +/- " <<effTP_MCerr <<endl;
cout<<"eff: "<< eff->getVal() <<" +/- " << eff->getError() <<endl;
cout<<"ndataPeakFail " << ndataFailPeak <<endl;
}
void 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 performFit(string inputDir, string inputParameterFile, string label,
string PassInputDataFilename, string FailInputDataFilename,
string PassSignalTemplateHistName, string FailSignalTemplateHistName)
{
gBenchmark->Start("fitZCat");
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
const Double_t mlow = 60;
const Double_t mhigh = 120;
const Int_t nbins = 24;
TString effType = inputDir;
// The fit variable - lepton invariant mass
RooRealVar* rooMass_ = new RooRealVar("Mass","m_{ee}",mlow, mhigh, "GeV/c^{2}");
RooRealVar Mass = *rooMass_;
Mass.setBins(nbins);
// Make the category variable that defines the two fits,
// namely whether the probe passes or fails the eff criteria.
RooCategory sample("sample","") ;
sample.defineType("Pass", 1) ;
sample.defineType("Fail", 2) ;
RooDataSet *dataPass = RooDataSet::read((inputDir+PassInputDataFilename).c_str(),RooArgList(Mass));
RooDataSet *dataFail = RooDataSet::read((inputDir+FailInputDataFilename).c_str(),RooArgList(Mass));
RooDataSet *dataCombined = new RooDataSet("dataCombined","dataCombined", RooArgList(Mass), RooFit::Index(sample),
RooFit::Import("Pass",*dataPass),
RooFit::Import("Fail",*dataFail));
//*********************************************************************************************
//Define Free Parameters
//*********************************************************************************************
RooRealVar* ParNumSignal = LoadParameters(inputParameterFile, label,"ParNumSignal");
RooRealVar* ParNumBkgPass = LoadParameters(inputParameterFile, label,"ParNumBkgPass");
RooRealVar* ParNumBkgFail = LoadParameters(inputParameterFile, label, "ParNumBkgFail");
RooRealVar* ParEfficiency = LoadParameters(inputParameterFile, label, "ParEfficiency");
RooRealVar* ParPassBackgroundExpCoefficient = LoadParameters(inputParameterFile, label, "ParPassBackgroundExpCoefficient");
RooRealVar* ParFailBackgroundExpCoefficient = LoadParameters(inputParameterFile, label, "ParFailBackgroundExpCoefficient");
RooRealVar* ParPassSignalMassShift = LoadParameters(inputParameterFile, label, "ParPassSignalMassShift");
RooRealVar* ParFailSignalMassShift = LoadParameters(inputParameterFile, label, "ParFailSignalMassShift");
RooRealVar* ParPassSignalResolution = LoadParameters(inputParameterFile, label, "ParPassSignalResolution");
RooRealVar* ParFailSignalResolution = LoadParameters(inputParameterFile, label, "ParFailSignalResolution");
// new RooRealVar ("ParPassSignalMassShift","ParPassSignalMassShift",-2.6079e-02,-10.0, 10.0); //ParPassSignalMassShift->setConstant(kTRUE);
// RooRealVar* ParFailSignalMassShift = new RooRealVar ("ParFailSignalMassShift","ParFailSignalMassShift",7.2230e-01,-10.0, 10.0); //ParFailSignalMassShift->setConstant(kTRUE);
// RooRealVar* ParPassSignalResolution = new RooRealVar ("ParPassSignalResolution","ParPassSignalResolution",6.9723e-01,0.0, 10.0); ParPassSignalResolution->setConstant(kTRUE);
// RooRealVar* ParFailSignalResolution = new RooRealVar ("ParFailSignalResolution","ParFailSignalResolution",1.6412e+00,0.0, 10.0); ParFailSignalResolution->setConstant(kTRUE);
//*********************************************************************************************
//
//Load Signal PDFs
//
//*********************************************************************************************
TFile *Zeelineshape_file = new TFile("res/photonEfffromZee.dflag1.eT1.2.gT40.mt15.root", "READ");
TH1* histTemplatePass = (TH1D*) Zeelineshape_file->Get(PassSignalTemplateHistName.c_str());
TH1* histTemplateFail = (TH1D*) Zeelineshape_file->Get(FailSignalTemplateHistName.c_str());
//Introduce mass shift coordinate transformation
// RooFormulaVar PassShiftedMass("PassShiftedMass","@0-@1",RooArgList(Mass,*ParPassSignalMassShift));
// RooFormulaVar FailShiftedMass("FailShiftedMass","@0-@1",RooArgList(Mass,*ParFailSignalMassShift));
RooGaussian *PassSignalResolutionFunction = new RooGaussian("PassSignalResolutionFunction","PassSignalResolutionFunction",Mass,*ParPassSignalMassShift,*ParPassSignalResolution);
RooGaussian *FailSignalResolutionFunction = new RooGaussian("FailSignalResolutionFunction","FailSignalResolutionFunction",Mass,*ParFailSignalMassShift,*ParFailSignalResolution);
RooDataHist* dataHistPass = new RooDataHist("dataHistPass","dataHistPass", RooArgSet(Mass), histTemplatePass);
RooDataHist* dataHistFail = new RooDataHist("dataHistFail","dataHistFail", RooArgSet(Mass), histTemplateFail);
RooHistPdf* signalShapePassTemplatePdf = new RooHistPdf("signalShapePassTemplatePdf", "signalShapePassTemplatePdf", Mass, *dataHistPass, 1);
RooHistPdf* signalShapeFailTemplatePdf = new RooHistPdf("signalShapeFailTemplatePdf", "signalShapeFailTemplatePdf", Mass, *dataHistFail, 1);
RooFFTConvPdf* signalShapePassPdf = new RooFFTConvPdf("signalShapePassPdf","signalShapePassPdf" , Mass, *signalShapePassTemplatePdf,*PassSignalResolutionFunction,2);
RooFFTConvPdf* signalShapeFailPdf = new RooFFTConvPdf("signalShapeFailPdf","signalShapeFailPdf" , Mass, *signalShapeFailTemplatePdf,*FailSignalResolutionFunction,2);
// Now define some efficiency/yield variables
RooFormulaVar* NumSignalPass = new RooFormulaVar("NumSignalPass", "ParEfficiency*ParNumSignal", RooArgList(*ParEfficiency,*ParNumSignal));
RooFormulaVar* NumSignalFail = new RooFormulaVar("NumSignalFail", "(1.0-ParEfficiency)*ParNumSignal", RooArgList(*ParEfficiency,*ParNumSignal));
//*********************************************************************************************
//
// Create Background PDFs
//
//*********************************************************************************************
RooExponential* bkgPassPdf = new RooExponential("bkgPassPdf","bkgPassPdf",Mass, *ParPassBackgroundExpCoefficient);
RooExponential* bkgFailPdf = new RooExponential("bkgFailPdf","bkgFailPdf",Mass, *ParFailBackgroundExpCoefficient);
//*********************************************************************************************
//
// Create Total PDFs
//
//*********************************************************************************************
RooAddPdf pdfPass("pdfPass","pdfPass",RooArgList(*signalShapePassPdf,*bkgPassPdf), RooArgList(*NumSignalPass,*ParNumBkgPass));
RooAddPdf pdfFail("pdfFail","pdfFail",RooArgList(*signalShapeFailPdf,*bkgFailPdf), RooArgList(*NumSignalFail,*ParNumBkgFail));
// PDF for simultaneous fit
RooSimultaneous totalPdf("totalPdf","totalPdf", sample);
totalPdf.addPdf(pdfPass,"Pass");
// totalPdf.Print();
totalPdf.addPdf(pdfFail,"Fail");
totalPdf.Print();
//*********************************************************************************************
//
// Perform Fit
//
//*********************************************************************************************
RooFitResult *fitResult = 0;
// ********* Fix with Migrad first ********** //
fitResult = totalPdf.fitTo(*dataCombined, RooFit::Save(true),
RooFit::Extended(true), RooFit::PrintLevel(-1));
fitResult->Print("v");
// // ********* Fit With Minos ********** //
// fitResult = totalPdf.fitTo(*dataCombined, RooFit::Save(true),
// RooFit::Extended(true), RooFit::PrintLevel(-1), RooFit::Minos());
// fitResult->Print("v");
// // ********* Fix Mass Shift and Fit For Resolution ********** //
// ParPassSignalMassShift->setConstant(kTRUE);
// ParFailSignalMassShift->setConstant(kTRUE);
// ParPassSignalResolution->setConstant(kFALSE);
// ParFailSignalResolution->setConstant(kFALSE);
// fitResult = totalPdf.fitTo(*dataCombined, RooFit::Save(true),
// RooFit::Extended(true), RooFit::PrintLevel(-1));
// fitResult->Print("v");
// // ********* Do Final Fit ********** //
// ParPassSignalMassShift->setConstant(kFALSE);
// ParFailSignalMassShift->setConstant(kFALSE);
// ParPassSignalResolution->setConstant(kTRUE);
// ParFailSignalResolution->setConstant(kTRUE);
// fitResult = totalPdf.fitTo(*dataCombined, RooFit::Save(true),
// RooFit::Extended(true), RooFit::PrintLevel(-1));
// fitResult->Print("v");
double nSignalPass = NumSignalPass->getVal();
double nSignalFail = NumSignalFail->getVal();
double denominator = nSignalPass + nSignalFail;
printf("\nFit results:\n");
if( fitResult->status() != 0 ){
std::cout<<"ERROR: BAD FIT STATUS"<<std::endl;
}
printf(" Efficiency = %.4f +- %.4f\n",
ParEfficiency->getVal(), ParEfficiency->getPropagatedError(*fitResult));
cout << "Signal Pass: "******"Signal Fail: " << nSignalFail << endl;
cout << "*********************************************************************\n";
cout << "Final Parameters\n";
cout << "*********************************************************************\n";
PrintParameter(ParNumSignal, label,"ParNumSignal");
PrintParameter(ParNumBkgPass, label,"ParNumBkgPass");
PrintParameter(ParNumBkgFail, label, "ParNumBkgFail");
PrintParameter(ParEfficiency , label, "ParEfficiency");
PrintParameter(ParPassBackgroundExpCoefficient , label, "ParPassBackgroundExpCoefficient");
PrintParameter(ParFailBackgroundExpCoefficient , label, "ParFailBackgroundExpCoefficient");
PrintParameter(ParPassSignalMassShift , label, "ParPassSignalMassShift");
PrintParameter(ParFailSignalMassShift , label, "ParFailSignalMassShift");
PrintParameter(ParPassSignalResolution , label, "ParPassSignalResolution");
PrintParameter(ParFailSignalResolution , label, "ParFailSignalResolution");
cout << endl << endl;
//--------------------------------------------------------------------------------------------------------------
// Make plots
//==============================================================================================================
TFile *canvasFile = new TFile("Efficiency_FitResults.root", "UPDATE");
RooAbsData::ErrorType errorType = RooAbsData::Poisson;
Mass.setBins(NBINSPASS);
TString cname = TString((label+"_Pass").c_str());
TCanvas *c = new TCanvas(cname,cname,800,600);
RooPlot* frame1 = Mass.frame();
frame1->SetMinimum(0);
dataPass->plotOn(frame1,RooFit::DataError(errorType));
pdfPass.plotOn(frame1,RooFit::ProjWData(*dataPass),
RooFit::Components(*bkgPassPdf),RooFit::LineColor(kRed));
pdfPass.plotOn(frame1,RooFit::ProjWData(*dataPass));
frame1->Draw("e0");
TPaveText *plotlabel = new TPaveText(0.23,0.87,0.43,0.92,"NDC");
plotlabel->SetTextColor(kBlack);
plotlabel->SetFillColor(kWhite);
plotlabel->SetBorderSize(0);
plotlabel->SetTextAlign(12);
plotlabel->SetTextSize(0.03);
plotlabel->AddText("CMS Preliminary 2010");
TPaveText *plotlabel2 = new TPaveText(0.23,0.82,0.43,0.87,"NDC");
plotlabel2->SetTextColor(kBlack);
plotlabel2->SetFillColor(kWhite);
plotlabel2->SetBorderSize(0);
plotlabel2->SetTextAlign(12);
plotlabel2->SetTextSize(0.03);
plotlabel2->AddText("#sqrt{s} = 7 TeV");
TPaveText *plotlabel3 = new TPaveText(0.23,0.75,0.43,0.80,"NDC");
plotlabel3->SetTextColor(kBlack);
plotlabel3->SetFillColor(kWhite);
plotlabel3->SetBorderSize(0);
plotlabel3->SetTextAlign(12);
plotlabel3->SetTextSize(0.03);
char temp[100];
sprintf(temp, "%.4f", LUMINOSITY);
plotlabel3->AddText((string("#int#font[12]{L}dt = ") +
temp + string(" pb^{ -1}")).c_str());
TPaveText *plotlabel4 = new TPaveText(0.6,0.82,0.8,0.87,"NDC");
plotlabel4->SetTextColor(kBlack);
plotlabel4->SetFillColor(kWhite);
plotlabel4->SetBorderSize(0);
plotlabel4->SetTextAlign(12);
plotlabel4->SetTextSize(0.03);
double nsig = ParNumSignal->getVal();
double nErr = ParNumSignal->getError();
double e = ParEfficiency->getVal();
double eErr = ParEfficiency->getError();
double corr = fitResult->correlation(*ParEfficiency, *ParNumSignal);
double err = ErrorInProduct(nsig, nErr, e, eErr, corr);
sprintf(temp, "Signal = %.2f #pm %.2f", NumSignalPass->getVal(), err);
plotlabel4->AddText(temp);
TPaveText *plotlabel5 = new TPaveText(0.6,0.77,0.8,0.82,"NDC");
plotlabel5->SetTextColor(kBlack);
plotlabel5->SetFillColor(kWhite);
plotlabel5->SetBorderSize(0);
plotlabel5->SetTextAlign(12);
plotlabel5->SetTextSize(0.03);
sprintf(temp, "Bkg = %.2f #pm %.2f", ParNumBkgPass->getVal(), ParNumBkgPass->getError());
plotlabel5->AddText(temp);
TPaveText *plotlabel6 = new TPaveText(0.6,0.87,0.8,0.92,"NDC");
plotlabel6->SetTextColor(kBlack);
plotlabel6->SetFillColor(kWhite);
plotlabel6->SetBorderSize(0);
plotlabel6->SetTextAlign(12);
plotlabel6->SetTextSize(0.03);
plotlabel6->AddText("Passing probes");
TPaveText *plotlabel7 = new TPaveText(0.6,0.72,0.8,0.77,"NDC");
plotlabel7->SetTextColor(kBlack);
plotlabel7->SetFillColor(kWhite);
plotlabel7->SetBorderSize(0);
plotlabel7->SetTextAlign(12);
plotlabel7->SetTextSize(0.03);
sprintf(temp, "Eff = %.3f #pm %.3f", ParEfficiency->getVal(), ParEfficiency->getErrorHi());
plotlabel7->AddText(temp);
TPaveText *plotlabel8 = new TPaveText(0.6,0.72,0.8,0.66,"NDC");
plotlabel8->SetTextColor(kBlack);
plotlabel8->SetFillColor(kWhite);
plotlabel8->SetBorderSize(0);
plotlabel8->SetTextAlign(12);
plotlabel8->SetTextSize(0.03);
sprintf(temp, "#chi^{2}/DOF = %.3f", frame1->chiSquare());
plotlabel8->AddText(temp);
plotlabel4->Draw();
plotlabel5->Draw();
plotlabel6->Draw();
plotlabel7->Draw();
plotlabel8->Draw();
// c->SaveAs( cname + TString(".eps"));
c->SaveAs( cname + TString(".gif"));
canvasFile->WriteTObject(c, c->GetName(), "WriteDelete");
Mass.setBins(NBINSFAIL);
cname = TString((label+"_Fail").c_str());
TCanvas* c2 = new TCanvas(cname,cname,800,600);
RooPlot* frame2 = Mass.frame();
frame2->SetMinimum(0);
dataFail->plotOn(frame2,RooFit::DataError(errorType));
pdfFail.plotOn(frame2,RooFit::ProjWData(*dataFail),
RooFit::Components(*bkgFailPdf),RooFit::LineColor(kRed));
pdfFail.plotOn(frame2,RooFit::ProjWData(*dataFail));
frame2->Draw("e0");
plotlabel = new TPaveText(0.23,0.87,0.43,0.92,"NDC");
plotlabel->SetTextColor(kBlack);
plotlabel->SetFillColor(kWhite);
plotlabel->SetBorderSize(0);
plotlabel->SetTextAlign(12);
plotlabel->SetTextSize(0.03);
plotlabel->AddText("CMS Preliminary 2010");
plotlabel2 = new TPaveText(0.23,0.82,0.43,0.87,"NDC");
plotlabel2->SetTextColor(kBlack);
plotlabel2->SetFillColor(kWhite);
plotlabel2->SetBorderSize(0);
plotlabel2->SetTextAlign(12);
plotlabel2->SetTextSize(0.03);
plotlabel2->AddText("#sqrt{s} = 7 TeV");
plotlabel3 = new TPaveText(0.23,0.75,0.43,0.80,"NDC");
plotlabel3->SetTextColor(kBlack);
plotlabel3->SetFillColor(kWhite);
plotlabel3->SetBorderSize(0);
plotlabel3->SetTextAlign(12);
plotlabel3->SetTextSize(0.03);
sprintf(temp, "%.4f", LUMINOSITY);
plotlabel3->AddText((string("#int#font[12]{L}dt = ") +
temp + string(" pb^{ -1}")).c_str());
plotlabel4 = new TPaveText(0.6,0.82,0.8,0.87,"NDC");
plotlabel4->SetTextColor(kBlack);
plotlabel4->SetFillColor(kWhite);
plotlabel4->SetBorderSize(0);
plotlabel4->SetTextAlign(12);
plotlabel4->SetTextSize(0.03);
err = ErrorInProduct(nsig, nErr, 1.0-e, eErr, corr);
sprintf(temp, "Signal = %.2f #pm %.2f", NumSignalFail->getVal(), err);
plotlabel4->AddText(temp);
plotlabel5 = new TPaveText(0.6,0.77,0.8,0.82,"NDC");
plotlabel5->SetTextColor(kBlack);
plotlabel5->SetFillColor(kWhite);
plotlabel5->SetBorderSize(0);
plotlabel5->SetTextAlign(12);
plotlabel5->SetTextSize(0.03);
sprintf(temp, "Bkg = %.2f #pm %.2f", ParNumBkgFail->getVal(), ParNumBkgFail->getError());
plotlabel5->AddText(temp);
plotlabel6 = new TPaveText(0.6,0.87,0.8,0.92,"NDC");
plotlabel6->SetTextColor(kBlack);
plotlabel6->SetFillColor(kWhite);
plotlabel6->SetBorderSize(0);
plotlabel6->SetTextAlign(12);
plotlabel6->SetTextSize(0.03);
plotlabel6->AddText("Failing probes");
plotlabel7 = new TPaveText(0.6,0.72,0.8,0.77,"NDC");
plotlabel7->SetTextColor(kBlack);
plotlabel7->SetFillColor(kWhite);
plotlabel7->SetBorderSize(0);
plotlabel7->SetTextAlign(12);
plotlabel7->SetTextSize(0.03);
sprintf(temp, "Eff = %.3f #pm %.3f", ParEfficiency->getVal(), ParEfficiency->getErrorHi(), ParEfficiency->getErrorLo());
plotlabel7->AddText(temp);
plotlabel8 = new TPaveText(0.6,0.72,0.8,0.66,"NDC");
plotlabel8->SetTextColor(kBlack);
plotlabel8->SetFillColor(kWhite);
plotlabel8->SetBorderSize(0);
plotlabel8->SetTextAlign(12);
plotlabel8->SetTextSize(0.03);
sprintf(temp, "#chi^{2}/DOF = %.3f", frame2->chiSquare());
plotlabel8->AddText(temp);
// plotlabel->Draw();
// plotlabel2->Draw();
// plotlabel3->Draw();
plotlabel4->Draw();
plotlabel5->Draw();
plotlabel6->Draw();
plotlabel7->Draw();
plotlabel8->Draw();
c2->SaveAs( cname + TString(".gif"));
// c2->SaveAs( cname + TString(".eps"));
// c2->SaveAs( cname + TString(".root"));
canvasFile->WriteTObject(c2, c2->GetName(), "WriteDelete");
canvasFile->Close();
effTextFile.width(40);
effTextFile << label;
effTextFile.width(20);
effTextFile << setiosflags(ios::fixed) << setprecision(4) << left << ParEfficiency->getVal() ;
effTextFile.width(20);
effTextFile << left << ParEfficiency->getErrorHi();
effTextFile.width(20);
effTextFile << left << ParEfficiency->getErrorLo();
effTextFile.width(14);
effTextFile << setiosflags(ios::fixed) << setprecision(2) << left << nSignalPass ;
effTextFile.width(14);
effTextFile << left << nSignalFail << endl;
}
//===============================================================================
void AbsorberStudy_RooFit(){
//===============================================================================
gStyle->SetOptTitle(0);
using namespace RooFit;
//The root files with the individual plots
const int numberoffiles = 20;
const int numberofabsorbers = 1;
TString filename[numberoffiles];
//e-
// filename[0]="Scream_50cmFeAbsorber_ele10GeV.root";
// filename[1]="Scream_50cmFeAbsorber_ele20GeV.root";
// filename[2]="Scream_50cmFeAbsorber_ele30GeV.root";
// filename[3]="Scream_50cmFeAbsorber_ele40GeV.root";
// filename[4]="Scream_50cmFeAbsorber_ele50GeV.root";
// filename[5]="Scream_50cmFeAbsorber_ele60GeV.root";
// filename[6]="Scream_50cmFeAbsorber_ele70GeV.root";
// filename[7]="Scream_50cmFeAbsorber_ele80GeV.root";
// filename[8]="Scream_50cmFeAbsorber_ele90GeV.root";
// filename[9]="Scream_50cmFeAbsorber_ele100GeV.root";
// filename[10]="Scream_50cmFeAbsorber_ele110GeV.root";
// filename[11]="Scream_50cmFeAbsorber_ele120GeV.root";
// filename[12]="Scream_50cmFeAbsorber_ele130GeV.root";
// filename[13]="Scream_50cmFeAbsorber_ele140GeV.root";
// filename[14]="Scream_50cmFeAbsorber_ele150GeV.root";
// filename[15]="Scream_50cmFeAbsorber_ele160GeV.root";
// filename[16]="Scream_50cmFeAbsorber_ele170GeV.root";
// filename[17]="Scream_50cmFeAbsorber_ele180GeV.root";
// filename[18]="Scream_50cmFeAbsorber_ele190GeV.root";
// filename[19]="Scream_50cmFeAbsorber_ele200GeV.root";
filename[0]="testcalo_e-_10.root";
filename[1]="testcalo_e-_20.root";
filename[2]="testcalo_e-_30.root";
filename[3]="testcalo_e-_40.root";
filename[4]="testcalo_e-_50.root";
filename[5]="testcalo_e-_60.root";
filename[6]="testcalo_e-_70.root";
filename[7]="testcalo_e-_80.root";
filename[8]="testcalo_e-_90.root";
filename[9]="testcalo_e-_100.root";
filename[10]="testcalo_e-_110.root";
filename[11]="testcalo_e-_120.root";
filename[12]="testcalo_e-_130.root";
filename[13]="testcalo_e-_140.root";
filename[14]="testcalo_e-_150.root";
filename[15]="testcalo_e-_160.root";
filename[16]="testcalo_e-_170.root";
filename[17]="testcalo_e-_180.root";
filename[18]="testcalo_e-_190.root";
filename[19]="testcalo_e-_200.root";
//Energy distributions we want to fit
TString energy[numberofabsorbers];
energy[0] = "histo/33";
//For the maxv and sigma plot
std::vector<double> ene;
std::vector<double> maxv;
std::vector<double> thesigma;
std::vector<double> eneerr;
std::vector<double> maxvr;
std::vector<double> thesigmaerr;
ene.push_back(10.);ene.push_back(20.);ene.push_back(30.);ene.push_back(40.);ene.push_back(50.);ene.push_back(60.);ene.push_back(70.);ene.push_back(80.);
ene.push_back(90.);ene.push_back(100.);ene.push_back(110.);ene.push_back(120.);ene.push_back(130.);ene.push_back(140.);ene.push_back(150.);ene.push_back(160.);
ene.push_back(170.);ene.push_back(180.);ene.push_back(190.);ene.push_back(200.);
//Useful parameters for the fitting
double I = 0.;
double histo_mean = 0.;
double RMS = 0.;
int division = 0;
float eneMIN = 0.;
float eneMAX = 0.;
float BIN_SIZE = 0.;
float histomaximum = 0.;
//======================================================================================
//Canvas
TCanvas *can[numberoffiles][numberofabsorbers];
TString canname;
TCanvas *canmaxv[numberoffiles];
//======================================================================================
//Read the files and histograms here
TFile* files[numberoffiles];
for (int k=0; k<numberoffiles; k++){
files[k]= new TFile(filename[k]);
}
TH1F * histo[numberoffiles][numberofabsorbers];
for (int i=0; i<numberoffiles; i++){
gROOT->Reset();
for (int k=0; k<numberofabsorbers; k++){
histo[i][k]= (TH1F*) files[i]->Get(energy[k]);
if (!histo[i][k]){std::cerr << "Could not get histogram " << energy[k] << "in file "
<< files[i]->GetName() << std::endl;}
std::cout << "=========================================================================" << std::endl;
std::cout << files[i]->GetName() << std::endl;
canname = filename[i] + histo[i][k]->GetName();
can[i][k] = new TCanvas(canname, canname,800,600);
can[i][k]->cd();
histo[i][k]->Draw();
// histo[i][k]->Scale(0.1);//This is for the 10 events I run.
//Set the initial values for the fitting
I = histo[i][k]->Integral();
histo_mean = histo[i][k]->GetMean();
RMS = histo[i][k]->GetRMS();
division = histo[i][k]->GetNbinsX();
eneMIN = histo[i][k]->GetBinLowEdge(1);
eneMAX = histo[i][k]->GetBinLowEdge(division+1);
BIN_SIZE = histo[i][k]->GetBinWidth(1);
histomaximum = histo[i][k]->GetBinContent(histo[i][k]->GetMaximumBin());
// Declare observable x
RooRealVar x("x","x",eneMIN,eneMAX) ;
eneMIN = histo[i][k]->GetMaximumBin() - RMS; eneMAX = histo[i][k]->GetMaximumBin() + RMS;
// std::cout << histo[i][k]->GetMaximumBin() << std::endl;
// eneMIN = 50; eneMAX = 200.;
x.setRange("fitRegion1",eneMIN , eneMAX );
RooDataHist dh("dh","dh",x,Import(*histo[i][k])) ;
RooPlot* frame = x.frame(Title(filename[i]), Bins(1000)) ;
dh.plotOn(frame,MarkerColor(2),MarkerSize(0.9),MarkerStyle(21)); //this will show histogram data points on canvas
dh.statOn(frame); //this will display hist stat on canvas
RooRealVar mean("mean","mean",histo_mean, eneMIN, eneMAX);
RooRealVar width("width","width",RMS, eneMIN, eneMAX);
RooRealVar sigma("sigma","sigma",RMS, eneMIN, eneMAX);
RooGaussian gauss("gauss","gauss",x,mean,sigma);
// RooExponential expo("expo", "exponential PDF", x, lambda);
// Construct landau(t,ml,sl) ;
//RooLandau landau("lx","lx",x,mean,sigma) ;
//RooBreitWigner BW1("BW1","Breit Wigner theory",x,mean,sigma);
RooVoigtian bwandgaus("bwandgaus", "Breit Wigner convoluted with gauss",x,mean,width,sigma);
//RooCBShape cryBall1("cryBall1","Crystal Ball resolution model", x, CBmean, CBsigma, CBalpha, CBn) ;
//RooFFTConvPdf bwxCryBall1("bwxCryBall1", "FFT Conv CryBall and BW", x, BW1, cryBall1);
// RooBreitWigner gauss("gauss","gauss",x,mean,sigma);
// RooVoigtian gauss("gauss","gauss",x,mean,width,sigma);
// RooFitResult* filters = gauss.fitTo(dh, NumCPU(4), Range(("fitRegion"+IntToString(i)).c_str()), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
RooFitResult* filters = gauss.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
//RooFitResult* filters = bwxCryBall1.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
// RooFitResult* filters = BW1.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
//RooFitResult* filters = bwandgaus.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
// RooFitResult* filters = sum.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
// RooFitResult* filters = gauss.fitTo(dh, NumCPU(4), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
//RooFitResult* filters = landau.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
gauss.plotOn(frame,LineColor(4));//this will show fit overlay on canvas
gauss.paramOn(frame); //this will display the fit parameters on canvas
filters->Print();
// // Access list of final fit parameter values
// std::cout << "final value of floating parameters" << std::endl ;
// filters->floatParsFinal().Print("s") ;
//mpc = fit->GetParameter(1) - mpshift * fit->GetParameter(2);
mpc = mean.getVal();
maxv.push_back(mpc);
maxvr.push_back( (mean.getError()) );
eneerr.push_back(0.);
thesigma.push_back( (sigma.getVal()) );
thesigmaerr.push_back( (sigma.getError()) );
// std::cout << "File " << filename[i] << " Eneer " << k << " MAXV "<< mpc << std::endl;
// can[i][k]->Print(canname + ".root",".root");
// can[i][k]->Close();
// // Draw all frames on a canvas
// can[k] = new TCanvas(filename[i], filename[i],800,600);
// can[k]->cd();
// gPad->SetLeftMargin(0.15);
// frame->GetXaxis()->SetTitle("E (GeV)");
// frame->GetXaxis()->SetTitleOffset(1.2);
// frame->GetXaxis()->SetRangeUser(0.,0.05);
// // float binsize = histo[i][k]->GetBinWidth(1);
// // char Bsize[50];
// //sprintf(Bsize,"Events per %2.2f",binsize);
// frame->GetYaxis()->SetTitle("Events");
//frame->GetYaxis()->SetTitleOffset(1.2);
frame->Draw() ;
// can[k]->Print(filename[i]+".pdf",".pdf");
// can[k]->Print(histogramname[k]+".png",".png");
// can[k]->Close();
can[i][k]->Print(canname + ".root",".root");
//can[i][k]->Close();
} // end of loop over histos
//For the multi plot
} // end of loop over files
TFile f("maxvandsigma.root","recreate");
TGraphErrors *grMAXV = new TGraphErrors(maxv.size(),&ene[0],&maxv[0],&maxvr[0],&eneerr[0]);
TGraphErrors *grSigma = new TGraphErrors(thesigma.size(),&ene[0],&thesigma[0],&thesigmaerr[0],&eneerr[0]);
//======================================================================================
//For the maxv plot
TCanvas *c1 = new TCanvas("c1","maxv",200,10,1200,968);
grMAXV->SetMarkerStyle(20);
grMAXV->SetMarkerSize(1.2);
grMAXV->Draw("APL");
c1->Update();
grMAXV->SetTitle( " Maximum energy loss for different e^{-} energies in Fe absorber " );
grMAXV->GetHistogram()->SetXTitle(" Energy (GeV) ");
grMAXV->GetHistogram()->SetYTitle(" Maximum energy loss location (mm) ");
grMAXV->GetYaxis()->SetRangeUser(50.,150.);
c1->Update();
//c1->Print("maxv.png",".png");
c1->Write();
c1->Close();
//======================================================================================
//For the sigma plot
TCanvas *c2 = new TCanvas("c2","sigma",200,10,1200,968);
grSigma->SetMarkerStyle(20);
grSigma->SetMarkerSize(1.2);
grSigma->Draw("APL");
c2->Update();
grSigma->SetTitle( " Sigma Value for different e^{-} energies " );
grSigma->GetHistogram()->SetXTitle(" Energy (GeV) ");
grSigma->GetHistogram()->SetYTitle(" Sigma (mm) ");
//grSigma->GetYaxis()->SetRangeUser(0.20,0.40);
c2->Update();
//c2->Print("sigma.png",".png");
c2->Write();
c2->Close();
f.Close();
}
void CreateTemplatesForW(TString CAT, TString CUT)
{
gROOT->ForceStyle();
RooMsgService::instance().setSilentMode(kTRUE);
RooMsgService::instance().setStreamStatus(0,kFALSE);
RooMsgService::instance().setStreamStatus(1,kFALSE);
TFile *infMC = TFile::Open("Histo_TT_TuneCUETP8M1_13TeV-powheg-pythia8.root");
TFile *infData = TFile::Open("Histo_JetHT.root");
TH1F *hMC,*hData;
RooDataHist *roohMC,*roohData;
RooAddPdf *signal,*qcd;
TString VAR,TAG;
float XMIN,XMAX;
VAR = "mW";
TAG = CUT+"_"+CAT;
XMIN = 20.;
XMAX = 160.;
RooWorkspace *w = new RooWorkspace("w","workspace");
//---- define observable ------------------------
RooRealVar *x = new RooRealVar("mW","mW",XMIN,XMAX);
w->import(*x);
//---- first do the data template ---------------
hData = (TH1F*)infData->Get("boosted/h_mW_"+CUT+"_0btag");
hData->Rebin(5);
roohData = new RooDataHist("roohistData","roohistData",RooArgList(*x),hData);
//---- QCD -----------------------------------
RooRealVar bBkg0("qcd_b0","qcd_b0",0.5,0,1);
RooRealVar bBkg1("qcd_b1","qcd_b1",0.5,0,1);
RooRealVar bBkg2("qcd_b2","qcd_b2",0.5,0,1);
RooRealVar bBkg3("qcd_b3","qcd_b3",0.5,0,1);
RooBernstein qcd1("qcd_brn","qcd_brn",*x,RooArgList(bBkg0,bBkg1,bBkg2,bBkg3));
RooRealVar mQCD("qcd_mean2" ,"qcd_mean2",40,0,100);
RooRealVar sQCD("qcd_sigma2","qcd_sigma2",20,0,50);
RooGaussian qcd2("qcd_gaus" ,"qcd_gaus",*x,mQCD,sQCD);
RooRealVar fqcd("qcd_f1","qcd_f1",0.5,0,1);
qcd = new RooAddPdf("qcd_pdf","qcd_pdf",qcd1,qcd2,fqcd);
//---- plots ---------------------------------------------------
TCanvas *canB = new TCanvas("Template_W_QCD_"+CUT+"_"+CAT,"Template_W_QCD_"+CUT+"_"+CAT,900,600);
RooFitResult *res = qcd->fitTo(*roohData,RooFit::Save());
res->Print();
RooPlot *frameB = x->frame();
roohData->plotOn(frameB);
qcd->plotOn(frameB);
qcd->plotOn(frameB,RooFit::Components("qcd_brn"),RooFit::LineColor(kRed),RooFit::LineWidth(2),RooFit::LineStyle(2));
qcd->plotOn(frameB,RooFit::Components("qcd_gaus"),RooFit::LineColor(kGreen+1),RooFit::LineWidth(2),RooFit::LineStyle(2));
frameB->GetXaxis()->SetTitle("m_{W} (GeV)");
frameB->Draw();
gPad->Update();
canB->Print("plots/"+TString(canB->GetName())+".pdf");
RooArgSet *parsQCD = (RooArgSet*)qcd->getParameters(roohData);
parsQCD->setAttribAll("Constant",true);
w->import(*qcd);
//---- then do the signal templates -------------
hMC = (TH1F*)infMC->Get("boosted/hWt_"+VAR+"_"+TAG);
roohMC = new RooDataHist("roohistTT","roohistTT",RooArgList(*x),hMC);
normMC = ((TH1F*)infMC->Get("eventCounter/GenEventWeight"))->GetSumOfWeights();
hMC->Rebin(2);
RooRealVar m("ttbar_mean","ttbar_mean",90,70,100);
RooRealVar s("ttbar_sigma","ttbar_sigma",20,0,50);
RooGaussian sig_core("ttbar_core","ttbar_core",*x,m,s);
RooRealVar bSig0("ttbar_b0","ttbar_b0",0.5,0,1);
RooRealVar bSig1("ttbar_b1","ttbar_b1",0.5,0,1);
RooRealVar bSig2("ttbar_b2","ttbar_b2",0.5,0,1);
RooRealVar bSig3("ttbar_b3","ttbar_b3",0.5,0,1);
RooRealVar bSig4("ttbar_b4","ttbar_b4",0.5,0,1);
RooRealVar bSig5("ttbar_b5","ttbar_b5",0.5,0,1);
RooRealVar bSig6("ttbar_b6","ttbar_b6",0.5,0,1);
RooRealVar bSig7("ttbar_b7","ttbar_b7",0.5,0,1);
RooRealVar bSig8("ttbar_b8","ttbar_b8",0.5,0,1);
RooBernstein sig_tail("ttbar_tail","ttbar_tail",*x,RooArgList(bSig0,bSig1,bSig2,bSig3,bSig4,bSig5,bSig6,bSig7,bSig8));
RooRealVar fcore("ttbar_fcore","ttbar_fcore",0.5,0,1);
signal = new RooAddPdf("ttbar_pdf","ttbar_pdf",RooArgList(sig_core,sig_tail),RooArgList(fcore));
TCanvas *canS = new TCanvas("Template_W_TT_"+CAT+"_"+CUT,"Template_W_TT_"+CAT+"_"+CUT,900,600);
res = signal->fitTo(*roohMC,RooFit::Save());
cout<<"mean = "<<m.getVal()<<" +/ "<<m.getError()<<", sigma = "<<s.getVal()<<" +/- "<<s.getError()<<endl;
//res->Print();
RooPlot *frameS = x->frame();
roohMC->plotOn(frameS);
signal->plotOn(frameS);
signal->plotOn(frameS,RooFit::Components("ttbar_core"),RooFit::LineColor(kRed),RooFit::LineWidth(2),RooFit::LineStyle(2));
signal->plotOn(frameS,RooFit::Components("ttbar_tail"),RooFit::LineColor(kGreen+1),RooFit::LineWidth(2),RooFit::LineStyle(2));
frameS->GetXaxis()->SetTitle("m_{W} (GeV)");
frameS->Draw();
gPad->Update();
canS->Print("plots/"+TString(canS->GetName())+".pdf");
RooArgSet *parsSig = (RooArgSet*)signal->getParameters(roohMC);
parsSig->setAttribAll("Constant",true);
w->import(*signal);
//w->Print();
w->writeToFile("templates_W_"+CUT+"_"+CAT+"_workspace.root");
}
void ws_constrained_profile3D( const char* wsfile = "rootfiles/ws-data-unblind.root",
const char* new_poi_name = "n_M234_H4_3b",
int npoiPoints = 20,
double poiMinVal = 0.,
double poiMaxVal = 20.,
double constraintWidth = 1.5,
double ymax = 10.,
int verbLevel=0 ) {
gStyle->SetOptStat(0) ;
//--- make output directory.
char command[10000] ;
sprintf( command, "basename %s", wsfile ) ;
TString wsfilenopath = gSystem->GetFromPipe( command ) ;
wsfilenopath.ReplaceAll(".root","") ;
char outputdirstr[1000] ;
sprintf( outputdirstr, "outputfiles/scans-%s", wsfilenopath.Data() ) ;
TString outputdir( outputdirstr ) ;
printf("\n\n Creating output directory: %s\n\n", outputdir.Data() ) ;
sprintf(command, "mkdir -p %s", outputdir.Data() ) ;
gSystem->Exec( command ) ;
//--- Tell RooFit to shut up about anything less important than an ERROR.
RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR) ;
if ( verbLevel > 0 ) { printf("\n\n Verbose level : %d\n\n", verbLevel) ; }
TFile* wstf = new TFile( wsfile ) ;
RooWorkspace* ws = dynamic_cast<RooWorkspace*>( wstf->Get("ws") );
if ( verbLevel > 0 ) { ws->Print() ; }
RooDataSet* rds = (RooDataSet*) ws->obj( "ra2b_observed_rds" ) ;
if ( verbLevel > 0 ) {
printf("\n\n\n ===== RooDataSet ====================\n\n") ;
rds->Print() ;
rds->printMultiline(cout, 1, kTRUE, "") ;
}
ModelConfig* modelConfig = (ModelConfig*) ws->obj( "SbModel" ) ;
RooAbsPdf* likelihood = modelConfig->GetPdf() ;
RooRealVar* rrv_mu_susy_all0lep = ws->var("mu_susy_all0lep") ;
if ( rrv_mu_susy_all0lep == 0x0 ) {
printf("\n\n\n *** can't find mu_susy_all0lep in workspace. Quitting.\n\n\n") ;
return ;
}
//-- do BG only.
rrv_mu_susy_all0lep->setVal(0.) ;
rrv_mu_susy_all0lep->setConstant( kTRUE ) ;
//-- do a prefit.
printf("\n\n\n ====== Pre fit with unmodified nll var.\n\n") ;
RooFitResult* dataFitResultSusyFixed = likelihood->fitTo(*rds, Save(true),Hesse(false),Minos(false),Strategy(1),PrintLevel(verbLevel));
int dataSusyFixedFitCovQual = dataFitResultSusyFixed->covQual() ;
if ( dataSusyFixedFitCovQual < 2 ) { printf("\n\n\n *** Failed fit! Cov qual %d. Quitting.\n\n", dataSusyFixedFitCovQual ) ; return ; }
double dataFitSusyFixedNll = dataFitResultSusyFixed->minNll() ;
if ( verbLevel > 0 ) {
dataFitResultSusyFixed->Print("v") ;
}
printf("\n\n Nll value, from fit result : %.3f\n\n", dataFitSusyFixedNll ) ;
delete dataFitResultSusyFixed ;
//-- Construct the new POI parameter.
RooAbsReal* new_poi_rar(0x0) ;
new_poi_rar = ws->var( new_poi_name ) ;
if ( new_poi_rar == 0x0 ) {
printf("\n\n New POI %s is not a variable. Trying function.\n\n", new_poi_name ) ;
new_poi_rar = ws->function( new_poi_name ) ;
if ( new_poi_rar == 0x0 ) {
printf("\n\n New POI %s is not a function. I quit.\n\n", new_poi_name ) ;
return ;
}
} else {
printf("\n\n New POI %s is a variable with current value %.1f.\n\n", new_poi_name, new_poi_rar->getVal() ) ;
}
if ( npoiPoints <=0 ) {
printf("\n\n Quitting now.\n\n" ) ;
return ;
}
double startPoiVal = new_poi_rar->getVal() ;
//--- The RooNLLVar is NOT equivalent to what minuit uses.
// RooNLLVar* nll = new RooNLLVar("nll","nll", *likelihood, *rds ) ;
// printf("\n\n Nll value, from construction : %.3f\n\n", nll->getVal() ) ;
//--- output of createNLL IS what minuit uses, so use that.
RooAbsReal* nll = likelihood -> createNLL( *rds, Verbose(true) ) ;
RooRealVar* rrv_poiValue = new RooRealVar( "poiValue", "poiValue", 0., -10000., 10000. ) ;
/// rrv_poiValue->setVal( poiMinVal ) ;
/// rrv_poiValue->setConstant(kTRUE) ;
RooRealVar* rrv_constraintWidth = new RooRealVar("constraintWidth","constraintWidth", 0.1, 0.1, 1000. ) ;
rrv_constraintWidth -> setVal( constraintWidth ) ;
rrv_constraintWidth -> setConstant(kTRUE) ;
if ( verbLevel > 0 ) {
printf("\n\n ======= debug likelihood print\n\n") ;
likelihood->Print("v") ;
printf("\n\n ======= debug nll print\n\n") ;
nll->Print("v") ;
}
//----------------------------------------------------------------------------------------------
RooMinuit* rminuit( 0x0 ) ;
RooMinuit* rminuit_uc = new RooMinuit( *nll ) ;
rminuit_uc->setPrintLevel(verbLevel-1) ;
rminuit_uc->setNoWarn() ;
rminuit_uc->migrad() ;
rminuit_uc->hesse() ;
RooFitResult* rfr_uc = rminuit_uc->fit("mr") ;
double floatParInitVal[10000] ;
char floatParName[10000][100] ;
int nFloatParInitVal(0) ;
RooArgList ral_floats = rfr_uc->floatParsFinal() ;
TIterator* floatParIter = ral_floats.createIterator() ;
{
RooRealVar* par ;
while ( (par = (RooRealVar*) floatParIter->Next()) ) {
sprintf( floatParName[nFloatParInitVal], "%s", par->GetName() ) ;
floatParInitVal[nFloatParInitVal] = par->getVal() ;
nFloatParInitVal++ ;
}
}
//-------
printf("\n\n Unbiased best value for new POI %s is : %7.1f\n\n", new_poi_rar->GetName(), new_poi_rar->getVal() ) ;
double best_poi_val = new_poi_rar->getVal() ;
char minuit_formula[10000] ;
sprintf( minuit_formula, "%s+%s*(%s-%s)*(%s-%s)",
nll->GetName(),
rrv_constraintWidth->GetName(),
new_poi_rar->GetName(), rrv_poiValue->GetName(),
new_poi_rar->GetName(), rrv_poiValue->GetName()
) ;
printf("\n\n Creating new minuit variable with formula: %s\n\n", minuit_formula ) ;
RooFormulaVar* new_minuit_var = new RooFormulaVar("new_minuit_var", minuit_formula,
RooArgList( *nll,
*rrv_constraintWidth,
*new_poi_rar, *rrv_poiValue,
*new_poi_rar, *rrv_poiValue
) ) ;
printf("\n\n Current value is %.2f\n\n",
new_minuit_var->getVal() ) ;
rminuit = new RooMinuit( *new_minuit_var ) ;
RooAbsReal* plot_var = nll ;
printf("\n\n Current value is %.2f\n\n",
plot_var->getVal() ) ;
rminuit->setPrintLevel(verbLevel-1) ;
if ( verbLevel <=0 ) { rminuit->setNoWarn() ; }
//----------------------------------------------------------------------------------------------
//-- If POI range is -1 to -1, automatically determine the range using the set value.
if ( poiMinVal < 0. && poiMaxVal < 0. ) {
printf("\n\n Automatic determination of scan range.\n\n") ;
if ( startPoiVal <= 0. ) {
printf("\n\n *** POI starting value zero or negative %g. Quit.\n\n\n", startPoiVal ) ;
return ;
}
poiMinVal = startPoiVal - 3.5 * sqrt(startPoiVal) ;
poiMaxVal = startPoiVal + 6.0 * sqrt(startPoiVal) ;
if ( poiMinVal < 0. ) { poiMinVal = 0. ; }
printf(" Start val = %g. Scan range: %g to %g\n\n", startPoiVal, poiMinVal, poiMaxVal ) ;
}
//----------------------------------------------------------------------------------------------
double poiVals_scanDown[1000] ;
double nllVals_scanDown[1000] ;
//-- Do scan down from best value.
printf("\n\n +++++ Starting scan down from best value.\n\n") ;
double minNllVal(1.e9) ;
for ( int poivi=0; poivi < npoiPoints/2 ; poivi++ ) {
////double poiValue = poiMinVal + poivi*(poiMaxVal-poiMinVal)/(1.*(npoiPoints-1)) ;
double poiValue = best_poi_val - poivi*(best_poi_val-poiMinVal)/(1.*(npoiPoints/2-1)) ;
rrv_poiValue -> setVal( poiValue ) ;
rrv_poiValue -> setConstant( kTRUE ) ;
//+++++++++++++++++++++++++++++++++++
rminuit->migrad() ;
rminuit->hesse() ;
RooFitResult* rfr = rminuit->save() ;
//+++++++++++++++++++++++++++++++++++
if ( verbLevel > 0 ) { rfr->Print("v") ; }
float fit_minuit_var_val = rfr->minNll() ;
printf(" %02d : poi constraint = %.2f : allvars : MinuitVar, createNLL, PV, POI : %.5f %.5f %.5f %.5f\n",
poivi, rrv_poiValue->getVal(), fit_minuit_var_val, nll->getVal(), plot_var->getVal(), new_poi_rar->getVal() ) ;
cout << flush ;
poiVals_scanDown[poivi] = new_poi_rar->getVal() ;
nllVals_scanDown[poivi] = plot_var->getVal() ;
if ( nllVals_scanDown[poivi] < minNllVal ) { minNllVal = nllVals_scanDown[poivi] ; }
delete rfr ;
} // poivi
printf("\n\n +++++ Resetting floats to best fit values.\n\n") ;
for ( int pi=0; pi<nFloatParInitVal; pi++ ) {
RooRealVar* par = ws->var( floatParName[pi] ) ;
par->setVal( floatParInitVal[pi] ) ;
} // pi.
printf("\n\n +++++ Starting scan up from best value.\n\n") ;
//-- Now do scan up.
double poiVals_scanUp[1000] ;
double nllVals_scanUp[1000] ;
for ( int poivi=0; poivi < npoiPoints/2 ; poivi++ ) {
double poiValue = best_poi_val + poivi*(poiMaxVal-best_poi_val)/(1.*(npoiPoints/2-1)) ;
rrv_poiValue -> setVal( poiValue ) ;
rrv_poiValue -> setConstant( kTRUE ) ;
//+++++++++++++++++++++++++++++++++++
rminuit->migrad() ;
rminuit->hesse() ;
RooFitResult* rfr = rminuit->save() ;
//+++++++++++++++++++++++++++++++++++
if ( verbLevel > 0 ) { rfr->Print("v") ; }
float fit_minuit_var_val = rfr->minNll() ;
printf(" %02d : poi constraint = %.2f : allvars : MinuitVar, createNLL, PV, POI : %.5f %.5f %.5f %.5f\n",
poivi, rrv_poiValue->getVal(), fit_minuit_var_val, nll->getVal(), plot_var->getVal(), new_poi_rar->getVal() ) ;
cout << flush ;
poiVals_scanUp[poivi] = new_poi_rar->getVal() ;
nllVals_scanUp[poivi] = plot_var->getVal() ;
if ( nllVals_scanUp[poivi] < minNllVal ) { minNllVal = nllVals_scanUp[poivi] ; }
delete rfr ;
} // poivi
double poiVals[1000] ;
double nllVals[1000] ;
int pointCount(0) ;
for ( int pi=0; pi<npoiPoints/2; pi++ ) {
poiVals[pi] = poiVals_scanDown[(npoiPoints/2-1)-pi] ;
nllVals[pi] = nllVals_scanDown[(npoiPoints/2-1)-pi] ;
pointCount++ ;
}
for ( int pi=1; pi<npoiPoints/2; pi++ ) {
poiVals[pointCount] = poiVals_scanUp[pi] ;
nllVals[pointCount] = nllVals_scanUp[pi] ;
pointCount++ ;
}
npoiPoints = pointCount ;
printf("\n\n --- TGraph arrays:\n") ;
for ( int i=0; i<npoiPoints; i++ ) {
printf(" %2d : poi = %6.1f, nll = %g\n", i, poiVals[i], nllVals[i] ) ;
}
printf("\n\n") ;
double nllDiffVals[1000] ;
double poiAtMinlnL(-1.) ;
double poiAtMinusDelta2(-1.) ;
double poiAtPlusDelta2(-1.) ;
for ( int poivi=0; poivi < npoiPoints ; poivi++ ) {
nllDiffVals[poivi] = 2.*(nllVals[poivi] - minNllVal) ;
double poiValue = poiMinVal + poivi*(poiMaxVal-poiMinVal)/(1.*npoiPoints) ;
if ( nllDiffVals[poivi] < 0.01 ) { poiAtMinlnL = poiValue ; }
if ( poiAtMinusDelta2 < 0. && nllDiffVals[poivi] < 2.5 ) { poiAtMinusDelta2 = poiValue ; }
if ( poiAtMinlnL > 0. && poiAtPlusDelta2 < 0. && nllDiffVals[poivi] > 2.0 ) { poiAtPlusDelta2 = poiValue ; }
} // poivi
printf("\n\n Estimates for poi at delta ln L = -2, 0, +2: %g , %g , %g\n\n", poiAtMinusDelta2, poiAtMinlnL, poiAtPlusDelta2 ) ;
//--- Main canvas
TCanvas* cscan = (TCanvas*) gDirectory->FindObject("cscan") ;
if ( cscan == 0x0 ) {
printf("\n Creating canvas.\n\n") ;
cscan = new TCanvas("cscan","Delta nll") ;
}
char gname[1000] ;
TGraph* graph = new TGraph( npoiPoints, poiVals, nllDiffVals ) ;
sprintf( gname, "scan_%s", new_poi_name ) ;
graph->SetName( gname ) ;
double poiBest(-1.) ;
double poiMinus1stdv(-1.) ;
double poiPlus1stdv(-1.) ;
double poiMinus2stdv(-1.) ;
double poiPlus2stdv(-1.) ;
double twoDeltalnLMin(1e9) ;
int nscan(1000) ;
for ( int xi=0; xi<nscan; xi++ ) {
double x = poiVals[0] + xi*(poiVals[npoiPoints-1]-poiVals[0])/(nscan-1) ;
double twoDeltalnL = graph -> Eval( x, 0, "S" ) ;
if ( poiMinus1stdv < 0. && twoDeltalnL < 1.0 ) { poiMinus1stdv = x ; printf(" set m1 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;}
if ( poiMinus2stdv < 0. && twoDeltalnL < 4.0 ) { poiMinus2stdv = x ; printf(" set m2 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;}
if ( twoDeltalnL < twoDeltalnLMin ) { poiBest = x ; twoDeltalnLMin = twoDeltalnL ; }
if ( twoDeltalnLMin < 0.3 && poiPlus1stdv < 0. && twoDeltalnL > 1.0 ) { poiPlus1stdv = x ; printf(" set p1 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;}
if ( twoDeltalnLMin < 0.3 && poiPlus2stdv < 0. && twoDeltalnL > 4.0 ) { poiPlus2stdv = x ; printf(" set p2 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;}
if ( xi%100 == 0 ) { printf( " %4d : poi=%6.2f, 2DeltalnL = %6.2f\n", xi, x, twoDeltalnL ) ; }
}
printf("\n\n POI estimate : %g +%g -%g [%g,%g], two sigma errors: +%g -%g [%g,%g]\n\n",
poiBest,
(poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv), poiMinus1stdv, poiPlus1stdv,
(poiPlus2stdv-poiBest), (poiBest-poiMinus2stdv), poiMinus2stdv, poiPlus2stdv
) ;
printf(" %s val,pm1sig,pm2sig: %7.2f %7.2f %7.2f %7.2f %7.2f\n",
new_poi_name, poiBest, (poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv), (poiPlus2stdv-poiBest), (poiBest-poiMinus2stdv) ) ;
char htitle[1000] ;
sprintf(htitle, "%s profile likelihood scan: -2ln(L/Lm)", new_poi_name ) ;
TH1F* hscan = new TH1F("hscan", htitle, 10, poiMinVal, poiMaxVal ) ;
hscan->SetMinimum(0.) ;
hscan->SetMaximum(ymax) ;
hscan->DrawCopy() ;
graph->SetLineColor(4) ;
graph->SetLineWidth(3) ;
graph->Draw("CP") ;
gPad->SetGridx(1) ;
gPad->SetGridy(1) ;
cscan->Update() ;
TLine* line = new TLine() ;
line->SetLineColor(2) ;
line->DrawLine(poiMinVal, 1., poiPlus1stdv, 1.) ;
line->DrawLine(poiMinus1stdv,0., poiMinus1stdv, 1.) ;
line->DrawLine(poiPlus1stdv ,0., poiPlus1stdv , 1.) ;
TText* text = new TText() ;
text->SetTextSize(0.04) ;
char tstring[1000] ;
sprintf( tstring, "%s = %.1f +%.1f -%.1f", new_poi_name, poiBest, (poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv) ) ;
text -> DrawTextNDC( 0.15, 0.85, tstring ) ;
sprintf( tstring, "68%% interval [%.1f, %.1f]", poiMinus1stdv, poiPlus1stdv ) ;
text -> DrawTextNDC( 0.15, 0.78, tstring ) ;
char hname[1000] ;
sprintf( hname, "hscanout_%s", new_poi_name ) ;
TH1F* hsout = new TH1F( hname,"scan results",4,0.,4.) ;
double obsVal(-1.) ;
hsout->SetBinContent(1, obsVal ) ;
hsout->SetBinContent(2, poiPlus1stdv ) ;
hsout->SetBinContent(3, poiBest ) ;
hsout->SetBinContent(4, poiMinus1stdv ) ;
TAxis* xaxis = hsout->GetXaxis() ;
xaxis->SetBinLabel(1,"Observed val.") ;
xaxis->SetBinLabel(2,"Model+1sd") ;
xaxis->SetBinLabel(3,"Model") ;
xaxis->SetBinLabel(4,"Model-1sd") ;
char outrootfile[10000] ;
sprintf( outrootfile, "%s/scan-ff-%s.root", outputdir.Data(), new_poi_name ) ;
char outpdffile[10000] ;
sprintf( outpdffile, "%s/scan-ff-%s.pdf", outputdir.Data(), new_poi_name ) ;
cscan->Update() ; cscan->Draw() ;
printf("\n Saving %s\n", outpdffile ) ;
cscan->SaveAs( outpdffile ) ;
//--- save in root file
printf("\n Saving %s\n", outrootfile ) ;
TFile fout(outrootfile,"recreate") ;
graph->Write() ;
hsout->Write() ;
fout.Close() ;
delete ws ;
wstf->Close() ;
}
//===============================================================================
void Calibration_RooFit(){
//===============================================================================
gStyle->SetOptTitle(0);
using namespace RooFit;
//The root files with the individual plots
const int numberoffiles = 4;
const int numberofchambers = 6;
TString filename[numberoffiles];
//mu-
filename[0]="testcalo_mu-_50.root";
filename[1]="testcalo_mu-_100.root";
filename[2]="testcalo_mu-_150.root";
filename[3]="testcalo_mu-_200.root";
//Energy distributions we want to fit
TString energy[numberofchambers];
//nosmear
// energy[0] = "histo/6";
// energy[1] = "histo/7";
// energy[2] = "histo/8";
// energy[3] = "histo/9";
// energy[4] = "histo/10";
// energy[5] = "histo/11";
//smeared
energy[0] = "histo/18";
energy[1] = "histo/19";
energy[2] = "histo/20";
energy[3] = "histo/21";
energy[4] = "histo/22";
energy[5] = "histo/23";
double mpshift = 0;//-0.22278298;
TGraphErrors *grMPV[numberoffiles];
TGraphErrors *grSigma[numberoffiles];
//For the mpv and sigma plot
std::vector<double> chamb;
std::vector<double> mpv;
std::vector<double> thesigma;
std::vector<double> chamr;
std::vector<double> mpvr;
std::vector<double> thesigmaerr;
chamb.push_back(1.);chamb.push_back(2.);chamb.push_back(3.);chamb.push_back(4.);chamb.push_back(5.);chamb.push_back(6.);
//Useful parameters for the fitting
double I = 0.;
double histo_mean = 0.;
double RMS = 0.;
int division = 0;
float eneMIN = 0.;
float eneMAX = 0.;
float BIN_SIZE = 0.;
float histomaximum = 0.;
//======================================================================================
//Canvas
TCanvas *can[numberoffiles][numberofchambers];
TString canname;
TCanvas *canmpv[numberoffiles];
//======================================================================================
//Read the files and histograms here
TFile* files[numberoffiles];
for (int k=0; k<numberoffiles; k++){
files[k]= new TFile(filename[k]);
}
TH1F * histo[numberoffiles][numberofchambers];
for (int i=0; i<numberoffiles; i++){
gROOT->Reset();
for (int k=0; k<numberofchambers; k++){
histo[i][k]= (TH1F*) files[i]->Get(energy[k]);
if (!histo[i][k]){std::cerr << "Could not get histogram " << energy[k] << "in file "
<< files[i]->GetName() << std::endl;}
std::cout << "=========================================================================" << std::endl;
std::cout << files[i]->GetName() << std::endl;
canname = filename[i] + histo[i][k]->GetName();
can[i][k] = new TCanvas(canname, canname,800,600);
can[i][k]->cd();
histo[i][k]->Draw();
//Set the initial values for the fitting
// I = histo[i][k]->Integral();
histo_mean = histo[i][k]->GetMean();
RMS = histo[i][k]->GetRMS();
division = histo[i][k]->GetNbinsX();
eneMIN = histo[i][k]->GetBinLowEdge(1);
eneMAX = histo[i][k]->GetBinLowEdge(division+1);
BIN_SIZE = histo[i][k]->GetBinWidth(1);
histomaximum = histo[i][k]->GetBinContent(histo[i][k]->GetMaximumBin());
// Declare observable x
RooRealVar x("x","x",eneMIN,eneMAX) ;
eneMAX = 0.05;
x.setRange("fitRegion1",eneMIN , eneMAX );
RooDataHist dh("dh","dh",x,Import(*histo[i][k])) ;
RooPlot* frame = x.frame(Title(filename[i]), Bins(1000)) ;
dh.plotOn(frame,MarkerColor(2),MarkerSize(0.9),MarkerStyle(21)); //this will show histogram data points on canvas
dh.statOn(frame); //this will display hist stat on canvas
RooRealVar mean("mean","mean",histo_mean, eneMIN, eneMAX);
RooRealVar width("width","width",RMS, eneMIN, eneMAX);
RooRealVar sigma("sigma","sigma",RMS, eneMIN, eneMAX);
// RooGaussian gauss("gauss","gauss",x,mean,sigma);
// RooExponential expo("expo", "exponential PDF", x, lambda);
// Construct landau(t,ml,sl) ;
RooLandau landau("lx","lx",x,mean,sigma) ;
// RooBreitWigner BW1("BW1","Breit Wigner theory",x,mean,sigma);
// RooVoigtian bwandgaus("bwandgaus", "Breit Wigner convoluted with gauss",x,mean,width,sigma);
// RooCBShape cryBall1("cryBall1","Crystal Ball resolution model", x, CBmean, CBsigma, CBalpha, CBn) ;
// RooFFTConvPdf bwxCryBall1("bwxCryBall1", "FFT Conv CryBall and BW", x, BW1, cryBall1);
// RooBreitWigner gauss("gauss","gauss",x,mean,sigma);
// RooVoigtian gauss("gauss","gauss",x,mean,width,sigma);
// RooFitResult* filters = gauss.fitTo(dh, NumCPU(4), Range(("fitRegion"+IntToString(i)).c_str()), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
// RooFitResult* filters = gauss.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
// RooFitResult* filters = bwxCryBall1.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
// RooFitResult* filters = BW1.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
// RooFitResult* filters = bwandgaus.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
// RooFitResult* filters = sum.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
// RooFitResult* filters = gauss.fitTo(dh, NumCPU(4), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
RooFitResult* filters = landau.fitTo(dh, NumCPU(4), Range("fitRegion1"), Save(true), SumW2Error(kTRUE), PrintLevel(-1));
landau.plotOn(frame,LineColor(4));//this will show fit overlay on canvas
landau.paramOn(frame); //this will display the fit parameters on canvas
filters->Print();
// // Access list of final fit parameter values
// std::cout << "final value of floating parameters" << std::endl ;
// filters->floatParsFinal().Print("s") ;
//mpc = fit->GetParameter(1) - mpshift * fit->GetParameter(2);
mpc = mean.getVal();
mpv.push_back(mpc * 1000.);
mpvr.push_back( (mean.getError()) * 1000.);
chamr.push_back(0.);
thesigma.push_back( (sigma.getVal()) * 1000.);
thesigmaerr.push_back( (sigma.getError()) * 1000.);
// std::cout << "File " << filename[i] << " Chamber " << k << " MPV "<< mpc << std::endl;
// can[i][k]->Print(canname + ".root",".root");
// can[i][k]->Close();
// // Draw all frames on a canvas
// can[k] = new TCanvas(filename[i], filename[i],800,600);
// can[k]->cd();
// gPad->SetLeftMargin(0.15);
// frame->GetXaxis()->SetTitle("E (GeV)");
// frame->GetXaxis()->SetTitleOffset(1.2);
frame->GetXaxis()->SetRangeUser(0.,0.05);
// // float binsize = histo[i][k]->GetBinWidth(1);
// // char Bsize[50];
// //sprintf(Bsize,"Events per %2.2f",binsize);
// frame->GetYaxis()->SetTitle("Events");
//frame->GetYaxis()->SetTitleOffset(1.2);
frame->Draw() ;
// can[k]->Print(filename[i]+".pdf",".pdf");
// can[k]->Print(histogramname[k]+".png",".png");
// can[k]->Close();
can[i][k]->Print(canname + ".root",".root");
can[i][k]->Close();
} // end of loop over histos
//For the multi plot
grMPV[i] = new TGraphErrors(mpv.size(),&chamb[0],&mpv[0],&mpvr[0],&chamr[0]);
grSigma[i] = new TGraphErrors(thesigma.size(),&chamb[0],&thesigma[0],&thesigmaerr[0],&chamr[0]);
mpv.clear();
mpvr.clear();
thesigma.clear();
thesigmaerr.clear();
chamr.clear();
} // end of loop over files
const Int_t nch = 6;
char *chamb_labels[nch] = {"Std1","Star","Mirror","Snake","Spider","Std2"};
TFile f("mpvandsigma.root","recreate");
//======================================================================================
//For the multi mpv plot
TCanvas *c1 = new TCanvas("c1","mpv",200,10,1200,968);
//Change the bin labels
grMPV[0]->GetXaxis()->SetBinLabel( grMPV[0]->GetXaxis()->FindBin(1.0) , chamb_labels[0]);
grMPV[0]->GetXaxis()->SetBinLabel( grMPV[0]->GetXaxis()->FindBin(2.0) , chamb_labels[1]);
grMPV[0]->GetXaxis()->SetBinLabel( grMPV[0]->GetXaxis()->FindBin(3.0) , chamb_labels[2]);
grMPV[0]->GetXaxis()->SetBinLabel( grMPV[0]->GetXaxis()->FindBin(4.0) , chamb_labels[3]);
grMPV[0]->GetXaxis()->SetBinLabel( grMPV[0]->GetXaxis()->FindBin(5.0) , chamb_labels[4]);
grMPV[0]->GetXaxis()->SetBinLabel( grMPV[0]->GetXaxis()->FindBin(6.0) , chamb_labels[5]);
grMPV[0]->GetXaxis()->SetTitleOffset(2.0);
grMPV[0]->GetYaxis()->SetTitleOffset(1.2);
grMPV[0]->GetXaxis()->SetLabelSize(0.06);
grMPV[0]->SetMarkerStyle(20);
grMPV[0]->SetMarkerSize(1.2);
grMPV[0]->SetMarkerColor(1);
grMPV[0]->SetLineColor(1);
grMPV[0]->Draw("APL");
c1->Update();
grMPV[1]->SetMarkerStyle(21);
grMPV[1]->SetMarkerSize(1.2);
grMPV[1]->SetMarkerColor(2);
grMPV[1]->SetLineColor(2);
grMPV[1]->Draw("PSL");
c1->Update();
grMPV[2]->SetMarkerStyle(22);
grMPV[2]->SetMarkerSize(1.2);
grMPV[2]->SetMarkerColor(3);
grMPV[2]->SetLineColor(3);
grMPV[2]->Draw("PSL");
c1->Update();
grMPV[3]->SetMarkerStyle(23);
grMPV[3]->SetMarkerSize(1.2);
grMPV[3]->SetMarkerColor(4);
grMPV[3]->SetLineColor(4);
grMPV[3]->Draw("PSL");
c1->Update();
TLegend *leg = new TLegend(0.8,0.6,0.89,0.89); //coordinates are fractions of pad dimensions
leg->AddEntry(grMPV[0],"50 GeV","LP");
leg->AddEntry(grMPV[1],"100 GeV","LP");
leg->AddEntry(grMPV[2],"150 GeV","LP");
leg->AddEntry(grMPV[3],"200 GeV","LP");
leg->SetFillColor(18);
leg->SetHeader(" #mu^{-} energies ");
leg->Draw("PS");
c1->Update();
grMPV[0]-> SetTitle( " Landau Most Probable Value for different #mu^{-} energies " );
grMPV[0]->GetHistogram()->SetXTitle(" Chamber ");
grMPV[0]->GetHistogram()->SetYTitle(" Landau MPV (MIPs) (keV) ");
grMPV[0]->GetYaxis()->SetRangeUser(0.65,0.95);
//grMPV[0]->GetXaxis()->SetRangeUser(0.,5000.);
c1->Update();
//c1->Print("mpv.png",".png");
c1->Write();
c1->Close();
//======================================================================================
//For the multi sigma plot
TCanvas *c2 = new TCanvas("c2","sigma",200,10,1200,968);
//Change the bin labels
grSigma[0]->GetXaxis()->SetBinLabel( grSigma[0]->GetXaxis()->FindBin(1.0) , chamb_labels[0]);
grSigma[0]->GetXaxis()->SetBinLabel( grSigma[0]->GetXaxis()->FindBin(2.0) , chamb_labels[1]);
grSigma[0]->GetXaxis()->SetBinLabel( grSigma[0]->GetXaxis()->FindBin(3.0) , chamb_labels[2]);
grSigma[0]->GetXaxis()->SetBinLabel( grSigma[0]->GetXaxis()->FindBin(4.0) , chamb_labels[3]);
grSigma[0]->GetXaxis()->SetBinLabel( grSigma[0]->GetXaxis()->FindBin(5.0) , chamb_labels[4]);
grSigma[0]->GetXaxis()->SetBinLabel( grSigma[0]->GetXaxis()->FindBin(6.0) , chamb_labels[5]);
grSigma[0]->GetXaxis()->SetTitleOffset(2.0);
grSigma[0]->GetYaxis()->SetTitleOffset(1.2);
grSigma[0]->GetXaxis()->SetLabelSize(0.06);
grSigma[0]->SetMarkerStyle(20);
grSigma[0]->SetMarkerSize(1.2);
grSigma[0]->SetMarkerColor(1);
grSigma[0]->SetLineColor(1);
grSigma[0]->Draw("APL");
c2->Update();
grSigma[1]->SetMarkerStyle(21);
grSigma[1]->SetMarkerSize(1.2);
grSigma[1]->SetMarkerColor(2);
grSigma[1]->SetLineColor(2);
grSigma[1]->Draw("PSL");
c2->Update();
grSigma[2]->SetMarkerStyle(22);
grSigma[2]->SetMarkerSize(1.2);
grSigma[2]->SetMarkerColor(3);
grSigma[2]->SetLineColor(3);
grSigma[2]->Draw("PSL");
c2->Update();
grSigma[3]->SetMarkerStyle(23);
grSigma[3]->SetMarkerSize(1.2);
grSigma[3]->SetMarkerColor(4);
grSigma[3]->SetLineColor(4);
grSigma[3]->Draw("PSL");
c2->Update();
TLegend *leg = new TLegend(0.8,0.6,0.89,0.89); //coordinates are fractions of pad dimensions
leg->AddEntry(grSigma[0],"50 GeV","LP");
leg->AddEntry(grSigma[1],"100 GeV","LP");
leg->AddEntry(grSigma[2],"150 GeV","LP");
leg->AddEntry(grSigma[3],"200 GeV","LP");
leg->SetFillColor(18);
leg->SetHeader(" #mu^{-} energies ");
leg->Draw("PS");
c2->Update();
grSigma[0]-> SetTitle( " Landau Sigma Value for different #mu^{-} energies " );
grSigma[0]->GetHistogram()->SetXTitle(" Chamber ");
grSigma[0]->GetHistogram()->SetYTitle(" Landau Sigma (keV) ");
grSigma[0]->GetYaxis()->SetRangeUser(0.20,0.40);
//grSigma[0]->GetXaxis()->SetRangeUser(0.,5000.);
c2->Update();
//c2->Print("sigma.png",".png");
c2->Write();
f.Close();
}
void fitA0(){
using namespace RooFit;
//gROOT->ProcessLine(".x Style.C");
const int n_sample = 13 ;
std::vector<TString> v_sample_names;
Float_t v_mean[n_sample];
v_sample_names.push_back("A05GeV_noW");
v_sample_names.push_back("A06GeV_noW");
v_sample_names.push_back("A07GeV_noW");
v_sample_names.push_back("A08GeV_noW");
v_sample_names.push_back("A09GeV_noW");
v_sample_names.push_back("A09.4GeV_noW");
v_sample_names.push_back("A09.8GeV_noW");
v_sample_names.push_back("A010.2GeV_noW");
v_sample_names.push_back("A010.35GeV_noW");
v_sample_names.push_back("A010.5GeV_noW");
v_sample_names.push_back("A011GeV_noW");
v_sample_names.push_back("A012GeV_noW");
v_sample_names.push_back("A013GeV_noW");
v_mean[0] = 5.;
v_mean[1] = 6.;
v_mean[2] = 7.;
v_mean[3] = 8.;
v_mean[4] = 9.;
v_mean[5] = 9.4;
v_mean[6] = 9.8;
v_mean[7] = 10.2;
v_mean[8] = 10.35;
v_mean[9] = 10.5;
v_mean[10] = 11.;
v_mean[11] = 12.;
v_mean[12] = 13.;
Float_t sigmaACB[n_sample];
Float_t sigmaACB_err[n_sample];
Float_t sigmaAGauss[n_sample];
Float_t sigmaAGauss_err[n_sample];
Float_t sigmaAFrac[n_sample];
Float_t sigmaAFrac_err[n_sample];
Float_t chi2[n_sample];
Float_t errX[n_sample];
TCanvas *can [n_sample] ;
TFile *fFits = new TFile("a0fits_CBGauss.root", "RECREATE");
RooDataHist *hdata1[n_sample];
for ( int iSample = 0; iSample < n_sample; iSample++ )
{
can[iSample] = new TCanvas(v_sample_names[iSample],v_sample_names[iSample]);
errX[iSample] = 0.;
RooRealVar invMass("invMass","M_{#mu#mu} [GeV/c^{2}]",v_mean[iSample]-0.5,v_mean[iSample]+0.3);
invMass.setBins(25);
// invMass.setRange("onlyA",v_mean[iSample]-(v_mean[iSample]/25),v_mean[iSample]+(v_mean[iSample]/35));
TFile f( "./"+v_sample_names[iSample] + ".root", "READ" ) ;
TTree *tInvMass = f.Get("tInvMass");
RooDataSet dataset("dataset","dataset",tInvMass,RooArgSet(invMass));
hdata1[iSample] = dataset.binnedClone();
RooRealVar mean("mean","a mean",v_mean[iSample],4.,14.);
RooRealVar sigmaCB("sigmaCB","a width",0.06,0.002,0.2);
RooRealVar sigmaGaus("sigmaGaus","a width",0.1, 0., 1.);
RooRealVar alpha("alpha","alpha",1.8);//,-5.,10.);
RooRealVar enne("enne","enne",1.);//,0.,200.);
RooCBShape pdfaCB("pdfaCB","pdfaCB",invMass,mean,sigmaCB,alpha,enne);
RooGaussian pdfaGaus("pdfaGauss","pdfaGauss",invMass,mean,sigmaGaus);
RooRealVar sigmaFrac("sigmaFrac","sigmaFrac",0.04,0.,1.);
// RooRealVar sigmaFrac2("sigmaFrac2","sigmaFrac2",0.3,0.,1.);
RooAddPdf pdfa("pdfa","pdfa",RooArgList(pdfaGaus,pdfaCB),RooArgList(sigmaFrac));//,sigmaFrac2));
RooRealVar Na0("Na0","Na0",4200.,0.,100000000.);
RooAddPdf TOTpdf("TOTpdf","TOTpdf",RooArgList(pdfa),RooArgList(Na0));
fFits->cd();
// RooChi2Var chi2Var("chi2","chi2",TOTpdf,*hdata1[iSample],Extended(1));
// RooMinuit m2(chi2Var);
// m2.migrad();
// m2.hesse();
// RooFitResult* fitRes = m2.save();
RooFitResult *fitRes = TOTpdf.fitTo(*hdata1[iSample],Extended(1),Save(1));//,Range("onlyA"));
fitRes->Print("v");
sigmaACB[iSample] = sigmaCB.getVal();
sigmaACB_err[iSample] = sigmaCB.getError();
sigmaAGauss[iSample] = sigmaGaus.getVal();
sigmaAGauss_err[iSample] = sigmaGaus.getError();
sigmaAFrac[iSample] = sigmaFrac.getVal();
sigmaAFrac[iSample] = sigmaFrac.getError();
RooPlot *xplot = invMass.frame();
hdata1[iSample]->plotOn(xplot);//, RooFit::Cut("region==region::Background"));
TOTpdf.plotOn(xplot);
chi2[iSample] = xplot->chiSquare();
can[iSample]->cd(0);
xplot->Draw();
can[iSample]->Write();
}
TFile f_out("SigmaA0_vs_mass_CBGauss.root", "RECREATE");
f_out.cd();
TCanvas *c1 = new TCanvas("graph","graph");
c1->Divide(2,2);
c1->cd(1);
TGraphErrors* sigmaA0CB = new TGraphErrors(n_sample, v_mean, sigmaACB, errX, sigmaACB_err);
sigmaA0CB->SetTitle("pseudoscalar");
sigmaA0CB->GetXaxis()->SetTitle("mass A0");
sigmaA0CB->GetYaxis()->SetTitle("sigma A CB");
sigmaA0CB->SetMarkerStyle(20);
sigmaA0CB->SetMarkerColor(kRed);
sigmaA0CB->SetFillColor(0);
sigmaA0CB->SetFillStyle(0);
gStyle->SetOptFit(1111);
sigmaA0CB->Fit("pol1","FQ");
sigmaA0CB->Draw("AP");
c1->cd(2);
TGraphErrors* sigmaA0Gauss = new TGraphErrors(n_sample, v_mean, sigmaAGauss, errX, sigmaAGauss_err);
sigmaA0Gauss->SetTitle(0);
sigmaA0Gauss->GetXaxis()->SetTitle("mass A0");
sigmaA0Gauss->GetYaxis()->SetTitle("sigma A gauss");
sigmaA0Gauss->SetMarkerStyle(20);
sigmaA0Gauss->SetMarkerColor(kRed);
sigmaA0Gauss->SetFillColor(0);
gStyle->SetOptFit(1111);
sigmaA0Gauss->Fit("pol1","FQ");
sigmaA0Gauss->Draw("AP");
c1->cd(3);
TGraphErrors* sigmaA0Frac = new TGraphErrors(n_sample, v_mean, sigmaAFrac, errX, sigmaAFrac_err);
sigmaA0Frac->SetTitle(0);
sigmaA0Frac->GetXaxis()->SetTitle("mass A0");
sigmaA0Frac->GetYaxis()->SetTitle("sigma Frac");
sigmaA0Frac->SetMarkerStyle(20);
sigmaA0Frac->SetMarkerColor(kRed);
sigmaA0Frac->SetFillColor(0);
sigmaA0Frac->Draw("AP");
c1->cd(4);
TGraph *chi2Fit = new TGraph(n_sample, v_mean, chi2);
chi2Fit->GetXaxis()->SetTitle("mass A0");
chi2Fit->GetYaxis()->SetTitle("Fit Chi2");
chi2Fit->SetMarkerStyle(21);
chi2Fit->SetMarkerColor(kBlue);
chi2Fit->Draw("AP");
}
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
bool fitCharmoniaMassModel( RooWorkspace& myws, // Local Workspace
const RooWorkspace& inputWorkspace, // Workspace with all the input RooDatasets
struct KinCuts& cut, // Variable containing all kinematic cuts
map<string, string>& parIni, // Variable containing all initial parameters
struct InputOpt& opt, // Variable with run information (kept for legacy purpose)
string outputDir, // Path to output directory
// Select the type of datasets to fit
string DSTAG, // Specifies the type of datasets: i.e, DATA, MCJPSINP, ...
bool isPbPb = false, // isPbPb = false for pp, true for PbPb
bool importDS = true, // Select if the dataset is imported in the local workspace
// Select the type of object to fit
bool incJpsi = true, // Includes Jpsi model
bool incPsi2S = true, // Includes Psi(2S) model
bool incBkg = true, // Includes Background model
// Select the fitting options
bool doFit = true, // Flag to indicate if we want to perform the fit
bool cutCtau = false, // Apply prompt ctau cuts
bool doConstrFit = false, // Do constrained fit
bool doSimulFit = false, // Do simultaneous fit
bool wantPureSMC = false, // Flag to indicate if we want to fit pure signal MC
const char* applyCorr ="", // Flag to indicate if we want corrected dataset and which correction
uint loadFitResult = false, // Load previous fit results
string inputFitDir = "", // Location of the fit results
int numCores = 2, // Number of cores used for fitting
// Select the drawing options
bool setLogScale = true, // Draw plot with log scale
bool incSS = false, // Include Same Sign data
bool zoomPsi = false, // Zoom Psi(2S) peak on extra pad
double binWidth = 0.05, // Bin width used for plotting
bool getMeanPT = false // Compute the mean PT (NEED TO FIX)
)
{
if (DSTAG.find("_")!=std::string::npos) DSTAG.erase(DSTAG.find("_"));
// Check if input dataset is MC
bool isMC = false;
if (DSTAG.find("MC")!=std::string::npos) {
if (incJpsi && incPsi2S) {
cout << "[ERROR] We can only fit one type of signal using MC" << endl; return false;
}
isMC = true;
}
wantPureSMC = (isMC && wantPureSMC);
bool cutSideBand = (incBkg && (!incPsi2S && !incJpsi));
bool applyWeight_Corr = ( strcmp(applyCorr,"") );
// Define the mass range
setMassCutParameters(cut, incJpsi, incPsi2S, isMC);
parIni["invMassNorm"] = Form("RooFormulaVar::%s('( -1.0 + 2.0*( @0 - @1 )/( @2 - @1) )', {%s, mMin[%.6f], mMax[%.6f]})", "invMassNorm", "invMass", cut.dMuon.M.Min, cut.dMuon.M.Max );
// Apply the ctau cuts to reject non-prompt charmonia
if (cutCtau) { setCtauCuts(cut, isPbPb); }
string COLL = (isPbPb ? "PbPb" : "PP" );
string plotLabelPbPb, plotLabelPP;
if (doSimulFit || !isPbPb) {
// Set models based on initial parameters
struct OniaModel model;
if (!setMassModel(model, parIni, false, incJpsi, incPsi2S, incBkg)) { return false; }
// Import the local datasets
double numEntries = 1000000;
string label = ((DSTAG.find("PP")!=std::string::npos) ? DSTAG.c_str() : Form("%s_%s", DSTAG.c_str(), "PP"));
if (wantPureSMC) label += "_NoBkg";
if (applyWeight_Corr) label += Form("_%s",applyCorr);
string dsName = Form("dOS_%s", label.c_str());
if (importDS) {
if ( !(myws.data(dsName.c_str())) ) {
int importID = importDataset(myws, inputWorkspace, cut, label, cutSideBand);
if (importID<0) { return false; }
else if (importID==0) { doFit = false; }
}
numEntries = myws.data(dsName.c_str())->sumEntries(); if (numEntries<=0) { doFit = false; }
}
else if (doFit && !(myws.data(dsName.c_str()))) { cout << "[ERROR] No local dataset was found to perform the fit!" << endl; return false; }
if (myws.data(dsName.c_str())) numEntries = myws.data(dsName.c_str())->sumEntries();
// Set global parameters
setMassGlobalParameterRange(myws, parIni, cut, incJpsi, incPsi2S, incBkg, wantPureSMC);
// Build the Fit Model
if (!buildCharmoniaMassModel(myws, model.PP, parIni, false, doConstrFit, doSimulFit, incBkg, incJpsi, incPsi2S, numEntries)) { return false; }
// Define plot names
if (incJpsi) { plotLabelPP += Form("_Jpsi_%s", parIni["Model_Jpsi_PP"].c_str()); }
if (incPsi2S) { plotLabelPP += Form("_Psi2S_%s", parIni["Model_Psi2S_PP"].c_str()); }
if (incBkg) { plotLabelPP += Form("_Bkg_%s", parIni["Model_Bkg_PP"].c_str()); }
if (wantPureSMC) plotLabelPP +="_NoBkg";
if (applyWeight_Corr) plotLabelPP +=Form("_%s",applyCorr);
}
if (doSimulFit || isPbPb) {
// Set models based on initial parameters
struct OniaModel model;
if (!setMassModel(model, parIni, true, incJpsi, incPsi2S, incBkg)) { return false; }
// Import the local datasets
double numEntries = 1000000;
string label = ((DSTAG.find("PbPb")!=std::string::npos) ? DSTAG.c_str() : Form("%s_%s", DSTAG.c_str(), "PbPb"));
if (wantPureSMC) label += "_NoBkg";
if (applyWeight_Corr) label += Form("_%s",applyCorr);
string dsName = Form("dOS_%s", label.c_str());
if (importDS) {
if ( !(myws.data(dsName.c_str())) ) {
int importID = importDataset(myws, inputWorkspace, cut, label, cutSideBand);
if (importID<0) { return false; }
else if (importID==0) { doFit = false; }
}
numEntries = myws.data(dsName.c_str())->sumEntries(); if (numEntries<=0) { doFit = false; }
}
else if (doFit && !(myws.data(dsName.c_str()))) { cout << "[ERROR] No local dataset was found to perform the fit!" << endl; return false; }
if (myws.data(dsName.c_str())) numEntries = myws.data(dsName.c_str())->sumEntries();
// Set global parameters
setMassGlobalParameterRange(myws, parIni, cut, incJpsi, incPsi2S, incBkg, wantPureSMC);
// Build the Fit Model
if (!buildCharmoniaMassModel(myws, model.PbPb, parIni, true, doConstrFit, doSimulFit, incBkg, incJpsi, incPsi2S, numEntries)) { return false; }
// Define plot names
if (incJpsi) { plotLabelPbPb += Form("_Jpsi_%s", parIni["Model_Jpsi_PbPb"].c_str()); }
if (incPsi2S) { plotLabelPbPb += Form("_Psi2S_%s", parIni["Model_Psi2S_PbPb"].c_str()); }
if (incBkg) { plotLabelPbPb += Form("_Bkg_%s", parIni["Model_Bkg_PbPb"].c_str()); }
if (wantPureSMC) plotLabelPbPb += "_NoBkg";
if (applyWeight_Corr) plotLabelPbPb += Form("_%s",applyCorr);
}
if (doSimulFit) {
// Create the combided datasets
RooCategory* sample = new RooCategory("sample","sample"); sample->defineType("PbPb"); sample->defineType("PP");
RooDataSet* combData = new RooDataSet("combData","combined data", *myws.var("invMass"), Index(*sample),
Import("PbPb", *((RooDataSet*)myws.data("dOS_DATA_PbPb"))),
Import("PP", *((RooDataSet*)myws.data("dOS_DATA_PP")))
);
myws.import(*sample);
// Create the combided models
RooSimultaneous* simPdf = new RooSimultaneous("simPdf", "simultaneous pdf", *sample);
simPdf->addPdf(*myws.pdf("pdfMASS_Tot_PbPb"), "PbPb"); simPdf->addPdf(*myws.pdf("pdfMASS_Tot_PP"), "PP");
myws.import(*simPdf);
// check if we have already done this fit. If yes, do nothing and return true.
string FileName = "";
setMassFileName(FileName, (inputFitDir=="" ? outputDir : inputFitDir), DSTAG, (plotLabelPP + plotLabelPbPb), cut, isPbPb, cutSideBand, doSimulFit);
if (gSystem->AccessPathName(FileName.c_str()) && inputFitDir!="") {
cout << "[WARNING] User Input File : " << FileName << " was not found!" << endl;
if (loadFitResult) return false;
setMassFileName(FileName, outputDir, DSTAG, (plotLabelPP + plotLabelPbPb), cut, isPbPb, cutSideBand, doSimulFit);
}
bool found = true; bool skipFit = !doFit;
RooArgSet *newpars = myws.pdf("simPdf")->getParameters(*(myws.var("invMass")));
myws.saveSnapshot("simPdf_parIni", *newpars, kTRUE);
found = found && isFitAlreadyFound(newpars, FileName, "simPdf");
if (loadFitResult) {
if ( loadPreviousFitResult(myws, FileName, DSTAG, false, (!isMC && !cutSideBand && loadFitResult==1), loadFitResult==1) ) { skipFit = true; } else { skipFit = false; }
if ( loadPreviousFitResult(myws, FileName, DSTAG, true, (!isMC && !cutSideBand && loadFitResult==1), loadFitResult==1) ) { skipFit = true; } else { skipFit = false; }
if (skipFit) { cout << "[INFO] This simultaneous mass fit was already done, so I'll load the fit results." << endl; }
myws.saveSnapshot("simPdf_parLoad", *newpars, kTRUE);
} else if (found) {
cout << "[INFO] This simultaneous mass fit was already done, so I'll just go to the next one." << endl;
return true;
}
// Do the simultaneous fit
if (skipFit==false) {
RooFitResult* fitResult = simPdf->fitTo(*combData, Offset(kTRUE), Extended(kTRUE), NumCPU(numCores), Range("MassWindow"), Save()); //, Minimizer("Minuit2","Migrad")
fitResult->Print("v");
myws.import(*fitResult, "fitResult_simPdf");
// Create the output files
int nBins = min(int( round((cut.dMuon.M.Max - cut.dMuon.M.Min)/binWidth) ), 1000);
drawMassPlot(myws, outputDir, opt, cut, parIni, plotLabelPP, DSTAG, false, incJpsi, incPsi2S, incBkg, cutCtau, doSimulFit, false, setLogScale, incSS, zoomPsi, nBins, getMeanPT);
drawMassPlot(myws, outputDir, opt, cut, parIni, plotLabelPbPb, DSTAG, true, incJpsi, incPsi2S, incBkg, cutCtau, doSimulFit, false, setLogScale, incSS, zoomPsi, nBins, getMeanPT);
// Save the results
string FileName = ""; setMassFileName(FileName, outputDir, DSTAG, (plotLabelPP + plotLabelPbPb), cut, isPbPb, cutSideBand, doSimulFit);
myws.saveSnapshot("simPdf_parFit", *newpars, kTRUE);
saveWorkSpace(myws, Form("%smass%s/%s/result", outputDir.c_str(), (cutSideBand?"SB":""), DSTAG.c_str()), FileName);
// Delete the objects used during the simultaneous fit
delete sample; delete combData; delete simPdf;
}
}
else {
// Define pdf and plot names
string pdfName = Form("pdfMASS_Tot_%s", COLL.c_str());
string plotLabel = (isPbPb ? plotLabelPbPb : plotLabelPP);
// Import the local datasets
string label = ((DSTAG.find(COLL.c_str())!=std::string::npos) ? DSTAG.c_str() : Form("%s_%s", DSTAG.c_str(), COLL.c_str()));
if (wantPureSMC) label += "_NoBkg";
if (applyWeight_Corr) label += Form("_%s",applyCorr);
string dsName = Form("dOS_%s", label.c_str());
// check if we have already done this fit. If yes, do nothing and return true.
string FileName = "";
setMassFileName(FileName, (inputFitDir=="" ? outputDir : inputFitDir), DSTAG, plotLabel, cut, isPbPb, cutSideBand);
if (gSystem->AccessPathName(FileName.c_str()) && inputFitDir!="") {
cout << "[WARNING] User Input File : " << FileName << " was not found!" << endl;
if (loadFitResult) return false;
setMassFileName(FileName, outputDir, DSTAG, plotLabel, cut, isPbPb, cutSideBand);
}
bool found = true; bool skipFit = !doFit;
RooArgSet *newpars = myws.pdf(pdfName.c_str())->getParameters(*(myws.var("invMass")));
found = found && isFitAlreadyFound(newpars, FileName, pdfName.c_str());
if (loadFitResult) {
if ( loadPreviousFitResult(myws, FileName, DSTAG, isPbPb, (!isMC && !cutSideBand && loadFitResult==1), loadFitResult==1) ) { skipFit = true; } else { skipFit = false; }
if (skipFit) { cout << "[INFO] This mass fit was already done, so I'll load the fit results." << endl; }
myws.saveSnapshot(Form("%s_parLoad", pdfName.c_str()), *newpars, kTRUE);
} else if (found) {
cout << "[INFO] This mass fit was already done, so I'll just go to the next one." << endl;
return true;
}
// Fit the Datasets
if (skipFit==false) {
bool isWeighted = myws.data(dsName.c_str())->isWeighted();
RooFitResult* fitResult(0x0);
if (doConstrFit)
{
cout << "[INFO] Performing constrained fit" << endl;
if (isPbPb) {
cout << "[INFO] Constrained variables: alpha, n, ratio of sigmas" << endl;
fitResult = myws.pdf(pdfName.c_str())->fitTo(*myws.data(dsName.c_str()), Extended(kTRUE), SumW2Error(isWeighted), Range(cutSideBand ? parIni["BkgMassRange_FULL_Label"].c_str() : "MassWindow"), ExternalConstraints(RooArgSet(*(myws.pdf("sigmaAlphaConstr")),*(myws.pdf("sigmaNConstr")),*(myws.pdf("sigmaRSigmaConstr")))), NumCPU(numCores), Save());
}
else {
cout << "[INFO] Constrained variables: alpha, n, ratio of sigmas" << endl;
fitResult = myws.pdf(pdfName.c_str())->fitTo(*myws.data(dsName.c_str()), Extended(kTRUE), SumW2Error(isWeighted), Range(cutSideBand ? parIni["BkgMassRange_FULL_Label"].c_str() : "MassWindow"), ExternalConstraints(RooArgSet(*(myws.pdf("sigmaAlphaConstr")),*(myws.pdf("sigmaNConstr")))), NumCPU(numCores), Save());
}
}
else
{
fitResult = myws.pdf(pdfName.c_str())->fitTo(*myws.data(dsName.c_str()), Extended(kTRUE), SumW2Error(isWeighted), Range(cutSideBand ? parIni["BkgMassRange_FULL_Label"].c_str() : "MassWindow"), NumCPU(numCores), Save());
}
fitResult->Print("v");
myws.import(*fitResult, Form("fitResult_%s", pdfName.c_str()));
// Create the output files
int nBins = min(int( round((cut.dMuon.M.Max - cut.dMuon.M.Min)/binWidth) ), 1000);
drawMassPlot(myws, outputDir, opt, cut, parIni, plotLabel, DSTAG, isPbPb, incJpsi, incPsi2S, incBkg, cutCtau, doSimulFit, wantPureSMC, setLogScale, incSS, zoomPsi, nBins, getMeanPT);
// Save the results
string FileName = ""; setMassFileName(FileName, outputDir, DSTAG, plotLabel, cut, isPbPb, cutSideBand);
myws.saveSnapshot(Form("%s_parFit", pdfName.c_str()), *newpars, kTRUE);
saveWorkSpace(myws, Form("%smass%s/%s/result", outputDir.c_str(), (cutSideBand?"SB":""), DSTAG.c_str()), FileName);
}
}
return true;
};
void rf103_interprfuncs()
{
/////////////////////////////////////////////////////////
// G e n e r i c i n t e r p r e t e d p . d . f . //
/////////////////////////////////////////////////////////
// Declare observable x
RooRealVar x("x","x",-20,20) ;
// C o n s t r u c t g e n e r i c p d f f r o m i n t e r p r e t e d e x p r e s s i o n
// -------------------------------------------------------------------------------------------------
// To construct a proper p.d.f, the formula expression is explicitly normalized internally by dividing
// it by a numeric integral of the expresssion over x in the range [-20,20]
//
RooRealVar alpha("alpha","alpha",5,0.1,10) ;
RooGenericPdf genpdf("genpdf","genpdf","(1+0.1*abs(x)+sin(sqrt(abs(x*alpha+0.1))))",RooArgSet(x,alpha)) ;
// S a m p l e , f i t a n d p l o t g e n e r i c p d f
// ---------------------------------------------------------------
// Generate a toy dataset from the interpreted p.d.f
RooDataSet* data = genpdf.generate(x,10000) ;
// Fit the interpreted p.d.f to the generated data
genpdf.fitTo(*data) ;
// Make a plot of the data and the p.d.f overlaid
RooPlot* xframe = x.frame(Title("Interpreted expression pdf")) ;
data->plotOn(xframe) ;
genpdf.plotOn(xframe) ;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// S t a n d a r d p . d . f a d j u s t w i t h i n t e r p r e t e d h e l p e r f u n c t i o n //
// //
// Make a gauss(x,sqrt(mean2),sigma) from a standard RooGaussian //
// //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// C o n s t r u c t s t a n d a r d p d f w i t h f o r m u l a r e p l a c i n g p a r a m e t e r
// ------------------------------------------------------------------------------------------------------------
// Construct parameter mean2 and sigma
RooRealVar mean2("mean2","mean^2",10,0,200) ;
RooRealVar sigma("sigma","sigma",3,0.1,10) ;
// Construct interpreted function mean = sqrt(mean^2)
RooFormulaVar mean("mean","mean","sqrt(mean2)",mean2) ;
// Construct a gaussian g2(x,sqrt(mean2),sigma) ;
RooGaussian g2("g2","h2",x,mean,sigma) ;
// G e n e r a t e t o y d a t a
// ---------------------------------
// Construct a separate gaussian g1(x,10,3) to generate a toy Gaussian dataset with mean 10 and width 3
RooGaussian g1("g1","g1",x,RooConst(10),RooConst(3)) ;
RooDataSet* data2 = g1.generate(x,1000) ;
// F i t a n d p l o t t a i l o r e d s t a n d a r d p d f
// -------------------------------------------------------------------
// Fit g2 to data from g1
RooFitResult* r = g2.fitTo(*data2,Save()) ;
r->Print() ;
// Plot data on frame and overlay projection of g2
RooPlot* xframe2 = x.frame(Title("Tailored Gaussian pdf")) ;
data2->plotOn(xframe2) ;
g2.plotOn(xframe2) ;
// Draw all frames on a canvas
TCanvas* c = new TCanvas("rf103_interprfuncs","rf103_interprfuncs",800,400) ;
c->Divide(2) ;
c->cd(1) ; gPad->SetLeftMargin(0.15) ; xframe->GetYaxis()->SetTitleOffset(1.4) ; xframe->Draw() ;
c->cd(2) ; gPad->SetLeftMargin(0.15) ; xframe2->GetYaxis()->SetTitleOffset(1.4) ; xframe2->Draw() ;
}
void CreateDataTemplates(double dX,int BRN_ORDER)
{
gROOT->ForceStyle();
RooMsgService::instance().setSilentMode(kTRUE);
for(int i=0;i<2;i++) {
RooMsgService::instance().setStreamStatus(i,kFALSE);
}
double XMIN = 80;
double XMAX = 200;
const int NSEL(2);
const int NCAT[NSEL] = {4,3};
const double MVA_BND[NSEL][NCAT[0]+1] = {{-0.6,0.0,0.7,0.84,1},{-0.1,0.4,0.8,1}};
char name[1000];
TString SELECTION[NSEL] = {"NOM","VBF"};
TString SELTAG[NSEL] = {"NOM","PRK"};
TString MASS_VAR[NSEL] = {"mbbReg[1]","mbbReg[2]"};
TFile *fBKG = TFile::Open("limit_BRN5+4_dX0p1_80-200_CAT0-6/output/bkg_shapes_workspace.root");
RooWorkspace *wBkg = (RooWorkspace*)fBKG->Get("w");
RooWorkspace *w = new RooWorkspace("w","workspace");
//RooRealVar x(*(RooRealVar*)wBkg->var("mbbReg"));
TTree *tr;
TH1F *h,*hBlind;
TCanvas *canFit[5];
RooDataHist *roohist[5],*roohist_blind[5];
TFile *fTransfer = TFile::Open("limit_BRN5+4_dX0p1_80-200_CAT0-6/output/transferFunctions.root");
TF1 *transFunc;
int counter(0);
int NPAR = BRN_ORDER;
for(int isel=0;isel<NSEL;isel++) {
TFile *fDATA = TFile::Open("flat/Fit_data_sel"+SELECTION[isel]+".root");
RooRealVar *brn[8];
RooArgSet brn_params;
if (isel == 1) {
NPAR = 4;
}
for(int ib=0;ib<=NPAR;ib++) {
brn[ib] = new RooRealVar("b"+TString::Format("%d",ib)+"_sel"+SELECTION[isel],"b"+TString::Format("%d",ib)+"_sel"+SELECTION[isel],0.5,0,10.);
brn_params.add(*brn[ib]);
}
for(int icat=0;icat<NCAT[isel];icat++) {
RooRealVar x("mbbReg_"+TString::Format("CAT%d",counter),"mbbReg_"+TString::Format("CAT%d",counter),XMIN,XMAX);
sprintf(name,"fitRatio_sel%s_CAT%d",SELTAG[isel].Data(),counter);
transFunc = (TF1*)fTransfer->Get(name);
transFunc->Print();
// --- The error on the tranfer function parameters is shrinked because the correlations are ingored.
// --- Must be consistent with TransferFunctions.C
float p0 = transFunc->GetParameter(0);
float e0 = transFunc->GetParError(0);
float p1 = transFunc->GetParameter(1);
float e1 = transFunc->GetParError(1);
float p2 = transFunc->GetParameter(2);
float e2 = transFunc->GetParError(2);
RooRealVar trans_p2(TString::Format("trans_p2_CAT%d",counter),TString::Format("trans_p2_CAT%d",counter),p2);
RooRealVar trans_p1(TString::Format("trans_p1_CAT%d",counter),TString::Format("trans_p1_CAT%d",counter),p1);
RooRealVar trans_p0(TString::Format("trans_p0_CAT%d",counter),TString::Format("trans_p0_CAT%d",counter),p0);
printf("%.2f %.2f %.2f\n",p0,p1,p2);
RooGenericPdf *transfer;
if (isel == 0) {
trans_p2.setError(0.5*e2);
trans_p1.setError(0.5*e1);
trans_p0.setError(0.5*e0);
transfer = new RooGenericPdf(TString::Format("transfer_CAT%d",counter),"@2*@0+@1",RooArgList(x,trans_p0,trans_p1));
}
else {
trans_p2.setError(0.05*e2);
trans_p1.setError(0.05*e1);
trans_p0.setError(0.05*e0);
transfer = new RooGenericPdf(TString::Format("transfer_CAT%d",counter),"@3*@0*@0+@2*@0+@1",RooArgList(x,trans_p0,trans_p1,trans_p2));
}
trans_p2.setConstant(kTRUE);
trans_p1.setConstant(kTRUE);
trans_p0.setConstant(kTRUE);
transfer->Print();
sprintf(name,"FitData_sel%s_CAT%d",SELECTION[isel].Data(),icat);
canFit[icat] = new TCanvas(name,name,900,600);
canFit[icat]->cd(1)->SetBottomMargin(0.4);
sprintf(name,"Hbb/events");
tr = (TTree*)fDATA->Get(name);
sprintf(name,"hMbb_%s_CAT%d",SELECTION[isel].Data(),icat);
int NBINS = (XMAX[isel][icat]-XMIN[isel][icat])/dX;
h = new TH1F(name,name,NBINS,XMIN[isel][icat],XMAX[isel][icat]);
sprintf(name,"hMbb_blind_%s_CAT%d",SELECTION[isel].Data(),icat);
hBlind = new TH1F(name,name,NBINS,XMIN[isel][icat],XMAX[isel][icat]);
sprintf(name,"mva%s>%1.2f && mva%s<=%1.2f",SELECTION[isel].Data(),MVA_BND[isel][icat],SELECTION[isel].Data(),MVA_BND[isel][icat+1]);
TCut cut(name);
sprintf(name,"mva%s>%1.2f && mva%s<=%1.2f && %s>100 && %s<150",SELECTION[isel].Data(),MVA_BND[isel][icat],SELECTION[isel].Data(),MVA_BND[isel][icat+1],MASS_VAR[isel].Data(),MASS_VAR[isel].Data());
TCut cutBlind(name);
tr->Draw(MASS_VAR[isel]+">>"+h->GetName(),cut);
tr->Draw(MASS_VAR[isel]+">>"+hBlind->GetName(),cutBlind);
sprintf(name,"yield_data_CAT%d",counter);
RooRealVar *Yield = new RooRealVar(name,name,h->Integral());
sprintf(name,"data_hist_CAT%d",counter);
roohist[icat] = new RooDataHist(name,name,x,h);
sprintf(name,"data_hist_blind_CAT%d",counter);
roohist_blind[icat] = new RooDataHist(name,name,x,hBlind);
RooAbsPdf *qcd_pdf;
if (icat == 0) {
for(int ib=0;ib<=NPAR;ib++) {
brn[ib]->setConstant(kFALSE);
}
sprintf(name,"qcd_model_CAT%d",counter);
RooBernstein *qcd_pdf_aux = new RooBernstein(name,name,x,brn_params);
qcd_pdf = dynamic_cast<RooAbsPdf*> (qcd_pdf_aux);
}
else {
for(int ib=0;ib<=NPAR;ib++) {
brn[ib]->setConstant(kTRUE);
}
sprintf(name,"qcd_model_aux1_CAT%d",counter);
RooBernstein *qcd_pdf_aux1 = new RooBernstein(name,name,x,brn_params);
sprintf(name,"qcd_model_CAT%d",counter);
RooProdPdf *qcd_pdf_aux2 = new RooProdPdf(name,name,RooArgSet(*transfer,*qcd_pdf_aux1));
qcd_pdf = dynamic_cast<RooAbsPdf*> (qcd_pdf_aux2);
}
sprintf(name,"Z_model_CAT%d",counter);
RooAbsPdf *z_pdf = (RooAbsPdf*)wBkg->pdf(name);
sprintf(name,"Top_model_CAT%d",counter);
RooAbsPdf *top_pdf = (RooAbsPdf*)wBkg->pdf(name);
sprintf(name,"yield_ZJets_CAT%d",counter);
RooRealVar *nZ = (RooRealVar*)wBkg->var(name);
sprintf(name,"yield_Top_CAT%d",counter);
RooRealVar *nT = (RooRealVar*)wBkg->var(name);
sprintf(name,"yield_QCD_CAT%d",counter);
RooRealVar nQCD(name,name,1000,0,1e+10);
nZ->setConstant(kTRUE);
nT->setConstant(kTRUE);
sprintf(name,"bkg_model_CAT%d",counter);
RooAddPdf model(name,name,RooArgList(*z_pdf,*top_pdf,*qcd_pdf),RooArgList(*nZ,*nT,nQCD));
RooFitResult *res = model.fitTo(*roohist[icat],RooFit::Save());
res->Print();
RooPlot* frame = x.frame();
RooPlot* frame1 = x.frame();
roohist[icat]->plotOn(frame);
model.plotOn(frame,LineWidth(2));
cout<<"chi2/ndof = "<<frame->chiSquare()<<endl;
RooHist *hresid = frame->residHist();
//model.plotOn(frame,RooFit::VisualizeError(*res,1,kFALSE),FillColor(kGray)MoveToBack());
model.plotOn(frame,Components(*qcd_pdf),LineWidth(2),LineColor(kBlack),LineStyle(kDashed));
model.plotOn(frame,Components(*z_pdf),LineWidth(2),LineColor(kBlue));
model.plotOn(frame,Components(*top_pdf),LineWidth(2),LineColor(kGreen+1));
frame->Draw();
gPad->Update();
TPad* pad = new TPad("pad", "pad", 0., 0., 1., 1.);
pad->SetTopMargin(0.6);
pad->SetFillColor(0);
pad->SetFillStyle(0);
pad->Draw();
pad->cd(0);
frame1->addPlotable(hresid,"p");
frame1->Draw();
for(int ib=0;ib<=NPAR;ib++) {
brn[ib]->setConstant(kFALSE);
}
if (icat > 0) {
trans_p2.setConstant(kFALSE);
trans_p1.setConstant(kFALSE);
trans_p0.setConstant(kFALSE);
}
if (isel == 0) {
w->import(trans_p1);
w->import(trans_p0);
}
else {
w->import(trans_p2);
w->import(trans_p1);
w->import(trans_p0);
}
w->import(*roohist[icat]);
w->import(*roohist_blind[icat]);
w->import(model);
w->import(*Yield);
counter++;
}// category loop
}// selection loop
w->Print();
w->writeToFile("data_shapes_workspace_"+TString::Format("BRN%d",BRN_ORDER)+".root");
}
double getSignalContribution(TH1D * h, double &syserr, TString someoptions=""){ //options: (CaC: cut and count without fitting; only stat error)
using namespace std;
using namespace RooFit;
double nSignalOS;
if(someoptions == "CaC"){
nSignalOS = h->Integral();
syserr = sqrt(h->getIntegral);
}
else{
double rangemin=h->GetXaxis()->GetXmin();
double rangemax=h->GetXaxis()->GetXmax();
RooRealVar mass("mass","mass",rangemin,rangemax);
mass.setRange("cutcut",rangemin,rangemax);
RooDataHist roohist("roohist","roohist",mass,Import(*h));
TString fitname=h->GetName();
RooPlot * frame = mass.frame(Title("Fit " + fitname));
roohist.plotOn(frame,MarkerColor(1),MarkerSize(0.9),MarkerStyle(21));
roohist.statOn(frame);
//signal parameter
RooRealVar nsig("nsig","nsig",1000.,0.,10000000.);
// VOIGTIAN FUNCTION
RooRealVar mean("mean","mean",91.2, 20.0,120.0);
RooRealVar width("width","width",5.0, 0.0, 100.0);
RooRealVar sigmaV("sigmaV","sigmaV",5.0, 0.0, 100.0);
RooVoigtian voigt("voigt","voigt",mass,mean,width,sigmaV);
//======// Parameters for CrystalBall
RooRealVar m0("M_{ll}", "Bias", 114., 80, 120,"GeV");
RooRealVar sigma("#sigma_{CB}","Width", 9.2,3.0,10.0);//,"GeV/c^{2}");
RooRealVar cut("#alpha","Cut", 6., 5., 7.);
RooRealVar power("#gamma","Power", 10., 1., 20.);
RooCBShape CrystalBall("CrystalBall", "A Crystal Ball Lineshape", mass, m0,sigma, cut, power);
//======//Parameters for Breit-Wigner Distribution
RooRealVar mRes("M_{ll}", "Z Resonance Mass", 91.2, 89,94);//,"GeV/c^{2}");
RooRealVar Gamma("#Gamma", "#Gamma", 4.0, 1.0,20.0);//,"GeV/c^{2}");
RooBreitWigner BreitWigner("BreitWigner","A Breit-Wigner Distribution",mass,mRes,Gamma);
// SIGNAL MODEL
RooFFTConvPdf ResolutionModel("Convolution","Convolution", mass, BreitWigner, CrystalBall);
//BG model
RooRealVar nbkg("nbkg","nbkg",10.,0.,200000.,"GeV");
RooRealVar bkg_slope("bkg_slope","slope of the background exponential mass PDF",-0.1,0.1);
RooExponential bkgModel("bkgModel","background mass PDF",mass,bkg_slope);
//add sig + bg
RooAddPdf pdfFinal("pdfFinal","pdfFinal",RooArgList(voigt,bkgModel),RooArgList(nsig,nbkg));
RooFitResult *fitResult = pdfFinal.fitTo(roohist, RooFit::Save(true),
RooFit::Extended(true), RooFit::PrintLevel(-1));
fitResult->Print();//"v"); //verbose
pdfFinal.plotOn(frame,LineColor(4));
pdfFinal.plotOn(frame,Components("bkgModel"),LineColor(kRed),LineStyle(kDashed));
pdfFinal.paramOn(frame);
nSignalOS = nsig.getVal();
double signError = nsig.getError();
cout << "\n\n\nsignal contribution: " << nSignalOS << " +- " << signError << " background contribution: " << nbkg.getVal() << endl;
TCanvas c = TCanvas(fitname+" Zmass",fitname + " Zmass",800,400) ;
c.cd() ; gPad->SetLeftMargin(0.15);
frame->Draw();
c.Write();
syserr=signError;
}
return nSignalOS;
}
void Fit(TString SIGNAL,TString HISTO,double scaleSGN)
{
gROOT->ForceStyle();
TFile *fDat = TFile::Open("Histo_flatTree_data_tmva"+SIGNAL+".root");
TFile *fBkg = TFile::Open("Histo_flatTree_qcd_weights_tmva"+SIGNAL+".root");
TFile *fSgn = TFile::Open("Histo_flatTree_"+SIGNAL+"_weights_tmva"+SIGNAL+".root");
TH1 *hDat = (TH1*)fDat->Get(HISTO);
TH1 *hBkgRaw = (TH1*)fBkg->Get(HISTO);
TH1 *hSgn = (TH1*)fSgn->Get(HISTO);
TH1 *hDat_JESlo = (TH1*)fDat->Get(HISTO+"_JESlo");
TH1 *hBkgRaw_JESlo = (TH1*)fBkg->Get(HISTO+"_JESlo");
TH1 *hSgn_JESlo = (TH1*)fSgn->Get(HISTO+"_JESlo");
TH1 *hDat_JESup = (TH1*)fDat->Get(HISTO+"_JESup");
TH1 *hBkgRaw_JESup = (TH1*)fBkg->Get(HISTO+"_JESup");
TH1 *hSgn_JESup = (TH1*)fSgn->Get(HISTO+"_JESup");
TH1F *hBkg = (TH1F*)hBkgRaw->Clone("Bkg");
TH1F *hBkg_JESlo = (TH1F*)hBkgRaw_JESlo->Clone("Bkg_JESlo");
TH1F *hBkg_JESup = (TH1F*)hBkgRaw_JESup->Clone("Bkg_JESup");
hBkg->Smooth(2);
hBkg_JESlo->Smooth(2);
hBkg_JESup->Smooth(2);
hSgn->Smooth(2);
hSgn_JESlo->Smooth(2);
hSgn_JESup->Smooth(2);
double lumi = 4967;
hBkg->Scale(lumi);
hBkg_JESlo->Scale(lumi);
hBkg_JESup->Scale(lumi);
double k_factor = hDat->Integral()/hBkg->Integral();
double k_factor_JESlo = hDat->Integral()/hBkg_JESlo->Integral();
double k_factor_JESup = hDat->Integral()/hBkg_JESup->Integral();
hBkg->Scale(k_factor);
cout<<"Signal entries = "<<hSgn->GetEntries()<<endl;
hSgn->Scale(lumi/scaleSGN);
hBkg_JESlo->Scale(k_factor_JESlo);
hSgn_JESlo->Scale(lumi/scaleSGN);
hBkg_JESup->Scale(k_factor_JESup);
hSgn_JESup->Scale(lumi/scaleSGN);
hSgn_JESlo->Scale(hSgn->Integral()/hSgn_JESlo->Integral());
hSgn_JESup->Scale(hSgn->Integral()/hSgn_JESup->Integral());
TH1 *hBkg_STATlo = (TH1*)hBkg->Clone(HISTO+"_STATlo");
TH1 *hSgn_STATlo = (TH1*)hSgn->Clone(HISTO+"_STATlo");
TH1 *hBkg_STATup = (TH1*)hBkg->Clone(HISTO+"_STATup");
TH1 *hSgn_STATup = (TH1*)hSgn->Clone(HISTO+"_STATup");
float y1,e1;
for(int i=0;i<hBkg->GetNbinsX();i++) {
y1 = hBkg->GetBinContent(i+1);
e1 = hBkg->GetBinError(i+1);
hBkg_STATlo->SetBinContent(i+1,y1-e1);
hBkg_STATup->SetBinContent(i+1,y1+e1);
y1 = hSgn->GetBinContent(i+1);
e1 = hSgn->GetBinError(i+1);
hSgn_STATlo->SetBinContent(i+1,y1-e1);
hSgn_STATup->SetBinContent(i+1,y1+e1);
}
hBkg_STATlo->Scale(hBkg->Integral()/hBkg_STATlo->Integral());
hBkg_STATup->Scale(hBkg->Integral()/hBkg_STATup->Integral());
hSgn_STATlo->Scale(hSgn->Integral()/hSgn_STATlo->Integral());
hSgn_STATup->Scale(hSgn->Integral()/hSgn_STATup->Integral());
double xMIN = hBkg->GetBinLowEdge(1);
double xMAX = hBkg->GetBinLowEdge(hBkg->GetNbinsX()+1);
double xMIN2 = hDat->GetBinLowEdge(hDat->FindFirstBinAbove(0.5));
double xMAX2 = hDat->GetBinLowEdge(hDat->FindLastBinAbove(0.5)+1);
RooRealVar x("x","x",xMIN2,xMAX2);
RooDataHist data("data","dataset with x",x,hDat);
RooDataHist bkg("qcd","bkg with x",x,hBkg);
RooDataHist sgn("signal","sgn with x",x,hSgn);
RooHistPdf bkgPDF("bkgPDF","bkgPDF",x,bkg,0);
RooHistPdf sgnPDF("sgnPDF","sgnPDF",x,sgn,0);
RooRealVar f("f","f",0,0.,1.);
RooAddPdf model("model","model",RooArgList(sgnPDF,bkgPDF),RooArgList(f));
RooFitResult* r = model.fitTo(data,Save());
r->Print("v");
double N = hDat->Integral();
double B = hBkg->Integral();
double S = hSgn->Integral();
double m = f.getVal();
double e = f.getError();
cout<<"k-factor = "<<k_factor<<endl;
cout<<N<<" "<<B<<" "<<S<<endl;
cout<<"Total cross section = "<<N/lumi<<" pb"<<endl;
cout<<"Model cross section = "<<S/lumi<<" pb"<<endl;
cout<<"Fitted signal strength = "<<m*N/S<<endl;
cout<<"Fitted signal error = "<<e*N/S<<endl;
double p = 0.95;
double xup = (N/S)*(m+sqrt(2.)*e*TMath::ErfInverse((1-p)*TMath::Erf(m/e)+p));
cout<<"Bayesian Upper limit = "<<xup<<endl;
RooPlot* frame1 = x.frame();
data.plotOn(frame1);
model.plotOn(frame1,Components("sgnPDF*"),LineStyle(1),LineWidth(2),LineColor(kGreen+1));
model.plotOn(frame1,Components("bkgPDF*"),LineStyle(1),LineWidth(2),LineColor(kRed));
model.plotOn(frame1,LineStyle(1),LineWidth(2),LineColor(kBlue));
//cout<<frame1->chiSquare()<<endl;
RooHist* hresid = frame1->residHist();
RooHist* hpull = frame1->pullHist();
RooPlot* frame2 = x.frame(Title("Residual Distribution"));
frame2->addPlotable(hresid,"P") ;
// Create a new frame to draw the pull distribution and add the distribution to the frame
RooPlot* frame3 = x.frame(Title("Pull Distribution"));
frame3->addPlotable(hpull,"P");
TCanvas* cFit = new TCanvas("fitANN_"+SIGNAL,"fitANN_"+SIGNAL,900,600);
gPad->SetLogy();
frame1->SetMaximum(1e+4);
frame1->SetMinimum(0.5);
frame1->GetXaxis()->SetTitle("ANN Output");
frame1->GetYaxis()->SetTitle("Events");
frame1->Draw();
cout<<frame1->nameOf(3)<<endl;
TLegend *leg = new TLegend(0.7,0.65,0.9,0.9);
leg->SetHeader(SIGNAL);
leg->AddEntry(frame1->findObject("h_data"),"data","P");
leg->AddEntry(frame1->findObject("model_Norm[x]"),"QCD+Signal","L");
leg->AddEntry(frame1->findObject("model_Norm[x]_Comp[bkgPDF*]"),"QCD","L");
leg->AddEntry(frame1->findObject("model_Norm[x]_Comp[sgnPDF*]"),"Signal","L");
leg->SetFillColor(0);
leg->SetBorderSize(0);
leg->SetTextFont(42);
leg->SetTextSize(0.04);
leg->Draw();
TCanvas* cPull = new TCanvas("pullANN_"+SIGNAL,"pullANN_"+SIGNAL,900,400);
frame3->GetXaxis()->SetTitle("ANN Output");
frame3->GetYaxis()->SetTitle("Pull");
frame3->Draw();
cout<<"Creating datacard"<<endl;
ofstream datacard;
datacard.open("datacard_"+SIGNAL+"_"+HISTO+".txt");
datacard.setf(ios::right);
datacard<<"imax 1"<<"\n";
datacard<<"jmax 1"<<"\n";
datacard<<"kmax *"<<"\n";
datacard<<"----------------"<<"\n";
datacard<<"shapes * * "<<SIGNAL+"_"+HISTO+"_input.root $PROCESS $PROCESS_$SYSTEMATIC"<<"\n";
datacard<<"----------------"<<"\n";
datacard<<"bin 1"<<"\n";
datacard<<"observation "<<N<<"\n";
datacard<<"----------------"<<"\n";
datacard<<"bin 1 1"<<"\n";
datacard<<"process signal background "<<"\n";
datacard<<"process 0 1"<<"\n";
datacard<<"rate "<<S<<" "<<B<<"\n";
datacard<<"----------------"<<"\n";
datacard<<"lumi lnN 1.022 1.022"<<"\n";
datacard<<"jes shape 1 1"<<"\n";
datacard<<"mcstat shape 1 1"<<"\n";
datacard<<"jer shape 0 0"<<"\n";
datacard.close();
TFile *out = new TFile(SIGNAL+"_"+HISTO+"_input.root","RECREATE");
out->cd();
hDat->Write("data_obs");
hBkg->Write("background");
hSgn->Write("signal");
hDat_JESlo->Write("data_obs_jesDown");
hBkg_JESlo->Write("background_jesDown");
hBkg_STATlo->Write("background_mcstatDown");
hSgn_STATlo->Write("signal_mcstatDown");
hSgn_JESlo->Write("signal_jesDown");
hDat_JESup->Write("data_obs_jesUp");
hBkg_JESup->Write("background_jesUp");
hBkg_STATup->Write("background_mcstatUp");
hSgn_JESup->Write("signal_jesUp");
hSgn_STATup->Write("signal_mcstatUp");
//----- JER placeholder ----------------
hBkg_JESlo->Write("background_jerDown");
hSgn_JESlo->Write("signal_jerDown");
hBkg_JESup->Write("background_jerUp");
hSgn_JESup->Write("signal_jerUp");
}
void fitqual_plots( const char* wsfile = "outputfiles/ws.root", const char* plottitle="" ) {
TText* tt_title = new TText() ;
tt_title -> SetTextAlign(33) ;
gStyle -> SetOptStat(0) ;
gStyle -> SetLabelSize( 0.06, "y" ) ;
gStyle -> SetLabelSize( 0.08, "x" ) ;
gStyle -> SetLabelOffset( 0.010, "y" ) ;
gStyle -> SetLabelOffset( 0.010, "x" ) ;
gStyle -> SetTitleSize( 0.07, "y" ) ;
gStyle -> SetTitleSize( 0.05, "x" ) ;
gStyle -> SetTitleOffset( 1.50, "x" ) ;
gStyle -> SetTitleH( 0.07 ) ;
gStyle -> SetPadLeftMargin( 0.15 ) ;
gStyle -> SetPadBottomMargin( 0.15 ) ;
gStyle -> SetTitleX( 0.10 ) ;
gDirectory->Delete("h*") ;
TFile* wstf = new TFile( wsfile ) ;
RooWorkspace* ws = dynamic_cast<RooWorkspace*>( wstf->Get("ws") );
ws->Print() ;
int bins_of_met = TMath::Nint( ws->var("bins_of_met")->getVal() ) ;
printf("\n\n Bins of MET : %d\n\n", bins_of_met ) ;
int bins_of_nb = TMath::Nint( ws->var("bins_of_nb")->getVal() ) ;
printf("\n\n Bins of nb : %d\n\n", bins_of_nb ) ;
int nb_lookup[10] ;
if ( bins_of_nb == 2 ) {
nb_lookup[0] = 2 ;
nb_lookup[1] = 4 ;
} else if ( bins_of_nb == 3 ) {
nb_lookup[0] = 2 ;
nb_lookup[1] = 3 ;
nb_lookup[2] = 4 ;
}
TCanvas* cfq1 = (TCanvas*) gDirectory->FindObject("cfq1") ;
if ( cfq1 == 0x0 ) {
if ( bins_of_nb == 3 ) {
cfq1 = new TCanvas("cfq1","hbb fit", 700, 1000 ) ;
} else if ( bins_of_nb == 2 ) {
cfq1 = new TCanvas("cfq1","hbb fit", 700, 750 ) ;
} else {
return ;
}
}
RooRealVar* rv_sig_strength = ws->var("sig_strength") ;
if ( rv_sig_strength == 0x0 ) { printf("\n\n *** can't find sig_strength in workspace.\n\n" ) ; return ; }
ModelConfig* modelConfig = (ModelConfig*) ws->obj( "SbModel" ) ;
RooDataSet* rds = (RooDataSet*) ws->obj( "hbb_observed_rds" ) ;
rds->Print() ;
rds->printMultiline(cout, 1, kTRUE, "") ;
RooAbsPdf* likelihood = modelConfig->GetPdf() ;
///RooFitResult* fitResult = likelihood->fitTo( *rds, Save(true), PrintLevel(0) ) ;
RooFitResult* fitResult = likelihood->fitTo( *rds, Save(true), PrintLevel(3) ) ;
fitResult->Print() ;
char hname[1000] ;
char htitle[1000] ;
char pname[1000] ;
//-- unpack observables.
int obs_N_msig[10][50] ; // first index is n btags, second is met bin.
int obs_N_msb[10][50] ; // first index is n btags, second is met bin.
const RooArgSet* dsras = rds->get() ;
TIterator* obsIter = dsras->createIterator() ;
while ( RooRealVar* obs = (RooRealVar*) obsIter->Next() ) {
for ( int nbi=0; nbi<bins_of_nb; nbi++ ) {
for ( int mbi=0; mbi<bins_of_met; mbi++ ) {
sprintf( pname, "N_%db_msig_met%d", nb_lookup[nbi], mbi+1 ) ;
if ( strcmp( obs->GetName(), pname ) == 0 ) { obs_N_msig[nbi][mbi] = TMath::Nint( obs -> getVal() ) ; }
sprintf( pname, "N_%db_msb_met%d", nb_lookup[nbi], mbi+1 ) ;
if ( strcmp( obs->GetName(), pname ) == 0 ) { obs_N_msb[nbi][mbi] = TMath::Nint( obs -> getVal() ) ; }
} // mbi.
} // nbi.
} // obs iterator.
printf("\n\n") ;
for ( int nbi=0; nbi<bins_of_nb; nbi++ ) {
printf(" nb=%d : ", nb_lookup[nbi] ) ;
for ( int mbi=0; mbi<bins_of_met; mbi++ ) {
printf(" sig=%3d, sb=%3d |", obs_N_msig[nbi][mbi], obs_N_msb[nbi][mbi] ) ;
} // mbi.
printf("\n") ;
} // nbi.
printf("\n\n") ;
int pad(1) ;
cfq1->Clear() ;
cfq1->Divide( 2, bins_of_nb+1 ) ;
for ( int nbi=0; nbi<bins_of_nb; nbi++ ) {
sprintf( hname, "h_bg_%db_msig_met", nb_lookup[nbi] ) ;
sprintf( htitle, "mass sig, %db, MET", nb_lookup[nbi] ) ;
TH1F* hist_bg_msig = new TH1F( hname, htitle, bins_of_met, 0.5, bins_of_met+0.5 ) ;
hist_bg_msig -> SetFillColor( kBlue-9 ) ;
labelBins( hist_bg_msig ) ;
sprintf( hname, "h_bg_%db_msb_met", nb_lookup[nbi] ) ;
sprintf( htitle, "mass sb, %db, MET", nb_lookup[nbi] ) ;
TH1F* hist_bg_msb = new TH1F( hname, htitle, bins_of_met, 0.5, bins_of_met+0.5 ) ;
hist_bg_msb -> SetFillColor( kBlue-9 ) ;
labelBins( hist_bg_msb ) ;
sprintf( hname, "h_sig_%db_msig_met", nb_lookup[nbi] ) ;
sprintf( htitle, "mass sig, %db, MET", nb_lookup[nbi] ) ;
TH1F* hist_sig_msig = new TH1F( hname, htitle, bins_of_met, 0.5, bins_of_met+0.5 ) ;
hist_sig_msig -> SetFillColor( kMagenta+2 ) ;
labelBins( hist_sig_msig ) ;
sprintf( hname, "h_sig_%db_msb_met", nb_lookup[nbi] ) ;
sprintf( htitle, "mass sb, %db, MET", nb_lookup[nbi] ) ;
TH1F* hist_sig_msb = new TH1F( hname, htitle, bins_of_met, 0.5, bins_of_met+0.5 ) ;
hist_sig_msb -> SetFillColor( kMagenta+2 ) ;
labelBins( hist_sig_msb ) ;
sprintf( hname, "h_all_%db_msig_met", nb_lookup[nbi] ) ;
sprintf( htitle, "mass sig, %db, MET", nb_lookup[nbi] ) ;
TH1F* hist_all_msig = new TH1F( hname, htitle, bins_of_met, 0.5, bins_of_met+0.5 ) ;
sprintf( hname, "h_all_%db_msb_met", nb_lookup[nbi] ) ;
sprintf( htitle, "mass sb, %db, MET", nb_lookup[nbi] ) ;
TH1F* hist_all_msb = new TH1F( hname, htitle, bins_of_met, 0.5, bins_of_met+0.5 ) ;
sprintf( hname, "h_data_%db_msig_met", nb_lookup[nbi] ) ;
sprintf( htitle, "mass sig, %db, MET", nb_lookup[nbi] ) ;
TH1F* hist_data_msig = new TH1F( hname, htitle, bins_of_met, 0.5, bins_of_met+0.5 ) ;
hist_data_msig -> SetLineWidth(2) ;
hist_data_msig -> SetMarkerStyle(20) ;
labelBins( hist_data_msig ) ;
sprintf( hname, "h_data_%db_msb_met", nb_lookup[nbi] ) ;
sprintf( htitle, "mass sb, %db, MET", nb_lookup[nbi] ) ;
TH1F* hist_data_msb = new TH1F( hname, htitle, bins_of_met, 0.5, bins_of_met+0.5 ) ;
hist_data_msb -> SetLineWidth(2) ;
hist_data_msb -> SetMarkerStyle(20) ;
labelBins( hist_data_msb ) ;
for ( int mbi=0; mbi<bins_of_met; mbi++ ) {
sprintf( pname, "mu_bg_%db_msig_met%d", nb_lookup[nbi], mbi+1 ) ;
RooAbsReal* mu_bg_msig = ws->function( pname ) ;
if ( mu_bg_msig == 0x0 ) { printf("\n\n *** ws missing %s\n\n", pname ) ; return ; }
hist_bg_msig -> SetBinContent( mbi+1, mu_bg_msig->getVal() ) ;
sprintf( pname, "mu_sig_%db_msig_met%d", nb_lookup[nbi], mbi+1 ) ;
RooAbsReal* mu_sig_msig = ws->function( pname ) ;
if ( mu_sig_msig == 0x0 ) { printf("\n\n *** ws missing %s\n\n", pname ) ; return ; }
hist_sig_msig -> SetBinContent( mbi+1, mu_sig_msig->getVal() ) ;
hist_all_msig -> SetBinContent( mbi+1, mu_bg_msig->getVal() + mu_sig_msig->getVal() ) ;
hist_data_msig -> SetBinContent( mbi+1, obs_N_msig[nbi][mbi] ) ;
sprintf( pname, "mu_bg_%db_msb_met%d", nb_lookup[nbi], mbi+1 ) ;
RooAbsReal* mu_bg_msb = ws->function( pname ) ;
if ( mu_bg_msb == 0x0 ) { printf("\n\n *** ws missing %s\n\n", pname ) ; return ; }
hist_bg_msb -> SetBinContent( mbi+1, mu_bg_msb->getVal() ) ;
sprintf( pname, "mu_sig_%db_msb_met%d", nb_lookup[nbi], mbi+1 ) ;
RooAbsReal* mu_sig_msb = ws->function( pname ) ;
if ( mu_sig_msb == 0x0 ) { printf("\n\n *** ws missing %s\n\n", pname ) ; return ; }
hist_sig_msb -> SetBinContent( mbi+1, mu_sig_msb->getVal() ) ;
hist_all_msb -> SetBinContent( mbi+1, mu_bg_msb->getVal() + mu_sig_msb->getVal() ) ;
hist_data_msb -> SetBinContent( mbi+1, obs_N_msb[nbi][mbi] ) ;
} // mbi.
cfq1->cd( pad ) ;
sprintf( hname, "h_stack_%db_msig_met", nb_lookup[nbi] ) ;
sprintf( htitle, "mass sig, %db, MET", nb_lookup[nbi] ) ;
THStack* hstack_msig = new THStack( hname, htitle ) ;
hstack_msig -> Add( hist_bg_msig ) ;
hstack_msig -> Add( hist_sig_msig ) ;
hist_data_msig -> Draw("e") ;
hstack_msig -> Draw("same") ;
hist_data_msig -> Draw("same e") ;
hist_data_msig -> Draw("same axis") ;
tt_title -> DrawTextNDC( 0.85, 0.85, plottitle ) ;
pad++ ;
cfq1->cd( pad ) ;
sprintf( hname, "h_stack_%db_msb_met", nb_lookup[nbi] ) ;
sprintf( htitle, "mass sig, %db, MET", nb_lookup[nbi] ) ;
THStack* hstack_msb = new THStack( hname, htitle ) ;
hstack_msb -> Add( hist_bg_msb ) ;
hstack_msb -> Add( hist_sig_msb ) ;
hist_data_msb -> Draw("e") ;
hstack_msb -> Draw("same") ;
hist_data_msb -> Draw("same e") ;
hist_data_msb -> Draw("same axis") ;
tt_title -> DrawTextNDC( 0.85, 0.85, plottitle ) ;
pad++ ;
} // nbi.
TH1F* hist_R_msigmsb = new TH1F( "h_R_msigmsb", "R msig/msb vs met bin", bins_of_met, 0.5, 0.5+bins_of_met ) ;
hist_R_msigmsb -> SetLineWidth(2) ;
hist_R_msigmsb -> SetMarkerStyle(20) ;
hist_R_msigmsb -> SetYTitle("R msig/msb") ;
labelBins( hist_R_msigmsb ) ;
for ( int mbi=0; mbi<bins_of_met; mbi++ ) {
sprintf( pname, "R_msigmsb_met%d", mbi+1 ) ;
RooRealVar* rrv_R = ws->var( pname ) ;
if ( rrv_R == 0x0 ) { printf("\n\n *** Can't find %s in ws.\n\n", pname ) ; return ; }
hist_R_msigmsb -> SetBinContent( mbi+1, rrv_R -> getVal() ) ;
hist_R_msigmsb -> SetBinError( mbi+1, rrv_R -> getError() ) ;
} // mbi.
cfq1->cd( pad ) ;
gPad->SetGridy(1) ;
hist_R_msigmsb -> SetMaximum(0.35) ;
hist_R_msigmsb -> Draw("e") ;
tt_title -> DrawTextNDC( 0.85, 0.85, plottitle ) ;
pad++ ;
cfq1->cd( pad ) ;
scan_sigstrength( wsfile ) ;
tt_title -> DrawTextNDC( 0.85, 0.25, plottitle ) ;
TString pdffile( wsfile ) ;
pdffile.ReplaceAll("ws-","fitqual-") ;
pdffile.ReplaceAll("root","pdf") ;
cfq1->SaveAs( pdffile ) ;
TString histfile( wsfile ) ;
histfile.ReplaceAll("ws-","fitqual-") ;
saveHist( histfile, "h*" ) ;
} // fitqual_plots
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;
}
}
}
void fitlambda(bool realdata=1){
gSystem->Load("libRooFit");
using namespace RooFit;
TFile *data;
if (realdata==1) data=new TFile("./RecoRoutines_Z-selection_data36pb.rew2.corr1.root","read");
if (realdata==0) data=new TFile("./RecoRoutines_Z-selection_ZJets_TuneZ2_7TeV_alpgen_tauola.rew2.corr1.root","read");
TString dir="MuPtScale0toinf/";
TString title="dimuonstree";
TTree *tree = (TTree*)data->Get((dir+title).Data());
RooRealVar RMpPt("RMpPt","RMpPt",0,400);
RooRealVar RMpEta("RMpEta","RMpEta",-10,10);
RooRealVar RMpPhi("RMpPhi","RMpPhi",-10,10);
RooRealVar RMmPt("RMmPt","RMmPt",0,400);
RooRealVar RMmEta("RMmEta","RMmEta",-10,10);
RooRealVar RMmPhi("RMmPhi","RMmPhi",-10,10);
RooRealVar RZmass("RZmass","RZmass",81.2,101.2);
RooDataSet dataset("dataset","dataset",RooArgSet(RMpPt,RMpEta,RMpPhi,RMmPt,RMmEta,RMmPhi,RZmass),StoreError(RooArgSet(RZmass)));
Double_t MpPt ;
Double_t MpEta;
Double_t MpPhi;
Double_t MmPt;
Double_t MmEta;
Double_t MmPhi;
Double_t Zmass;
Double_t EvWeight;
tree->SetBranchAddress("MpPt",&MpPt);
tree->SetBranchAddress("MpEta",&MpEta);
tree->SetBranchAddress("MpPhi",&MpPhi);
tree->SetBranchAddress("MmPt",&MmPt);
tree->SetBranchAddress("MmEta",&MmEta);
tree->SetBranchAddress("MmPhi",&MmPhi);
tree->SetBranchAddress("Zmass",&Zmass);
tree->SetBranchAddress("EvWeight",&EvWeight);
Long64_t nentries = tree->GetEntries();
for (Long64_t i=0;i<nentries;i++) {
tree->GetEntry(i);
RMpPt=MpPt;
RMpEta=MpEta;
RMpPhi=MpPhi;
RMmPt=MmPt;
RMmEta=MmEta;
RMmPhi=MmPhi;
RZmass=Zmass;
RZmass.setError(3);
dataset.add(RooArgSet(RMpPt,RMpEta,RMpPhi,RMmPt,RMmEta,RMmPhi,RZmass),EvWeight);
}
RooRealVar mean("mean","mean",91.2,85.0,95.0);
RooRealVar cs01("cs01","cs01",0,-0.00,0.00);
RooRealVar cs02("cs02","cs02",0,-0.00,0.00);
RooRealVar ca01("ca01","ca01",0,-0.00,0.00);
RooRealVar ca02("ca02","ca02",0,-0.05,0.05);
RooRealVar cas1("cas1","cas1",0,-0.00,0.00);
RooRealVar cas2("cas2","cas2",0,-0.05,0.05);
RooRealVar phase("phase","phase",0,-3.14,3.14);
RooRealVar cae1("cae1","cae1",0,-0.00,0.00);
RooRealVar caeB2("caeB2","caeB2",0,-0.05,0.05);
RooRealVar caeE2("caeE2","caeE2",0,-0.05,0.05);
RooArgSet deps(RMpPt,RMmPt,RMpPhi,RMmPhi,RMpEta,RMmEta);
deps.add(mean);
deps.add(cs01);
deps.add(cs02);
deps.add(ca01);
deps.add(ca02);
deps.add(cas1);
deps.add(cas2);
deps.add(phase);
deps.add(cae1);
deps.add(caeB2);
deps.add(caeE2);
// corrfunction:
// dp/p = CS01+CS02*p+charge*(CA01+CA02*p)+charge*(CAS1+CAS2*p)*sin(phi+PHASE)+charge*(CAE1+CAE2*p)*eta
// 0.5*(caeB2+caeE2+TMath::Sign(caeB2,1-abs(eta))+TMath::Sign(caeE2,abs(eta)-1))
RooFormulaVar model("model","mean+mean/2*(cs01+cs02*RMpPt/100+(ca01+ca02*RMpPt/100)+(cas1+cas2*RMpPt/100)*sin(RMpPhi+phase)+\
(cae1+0.5*(caeB2+caeE2+TMath::Sign(caeB2,0.5-abs(RMpEta))+TMath::Sign(caeE2,abs(RMpEta)-0.5))*RMpPt/100)*RMpEta)\
+mean/2*(cs01+cs02*RMmPt/100-(ca01+ca02*RMmPt/100)-(cas1+cas2*RMmPt/100)*sin(RMmPhi+phase)-\
(cae1+0.5*(caeB2+caeE2+TMath::Sign(caeB2,0.5-abs(RMmEta))+TMath::Sign(caeE2,abs(RMmEta)-0.5))*RMmPt/100)*RMmEta)",deps);
RooFitResult *r = model.chi2FitTo(dataset,YVar(RZmass),Save());
r->Print();
RooPlot* frame = RMpPhi.frame() ;
dataset.plotOnXY(frame,YVar(RZmass));
model.plotOn(frame);
frame->Draw();
};
void fitWWa_el() {
TFile* fin = new TFile("../RunII_WVA_ControlPlots.root");
TH1D* data_obs = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/data_obs");
TH1D* th1fkdata = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1FakePhotons");
TH1D* th1wwa = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1wwa");
TH1D* th1wza = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1wza");
TH1D* th1wajets = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1wajets");
TH1D* th1zajets = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1zajets");
TH1D* th1Top = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1ttajets");
TH1D* th1tajets = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1tajets");
int NbinsX = data_obs->GetNbinsX();
double xmin = data_obs->GetXaxis()->GetBinLowEdge(1);
double xmax = data_obs->GetXaxis()->GetBinLowEdge(NbinsX+1);
data_obs->GetXaxis()->SetRangeUser(xmin, xmax);
th1fkdata->GetXaxis()->SetRangeUser(xmin, xmax);
th1wwa->GetXaxis()->SetRangeUser(xmin, xmax);
th1wza->GetXaxis()->SetRangeUser(xmin, xmax);
th1wajets->GetXaxis()->SetRangeUser(xmin, xmax);
th1zajets->GetXaxis()->SetRangeUser(xmin, xmax);
th1Top->GetXaxis()->SetRangeUser(xmin, xmax);
th1tajets->GetXaxis()->SetRangeUser(xmin, xmax);
th1wwa->Add(th1wza);
th1Top->Add(th1tajets);
mjj_ = new RooRealVar( "Mjj", "m_{jj}", xmin, xmax, "GeV");
RooRealVar Mass = *mjj_;
RooDataHist* data = new RooDataHist("data","data", *mjj_, data_obs);
RooHistPdf* pdffk = makePdf(th1fkdata, "pdffk");
RooHistPdf* pdfwwa = makePdf(th1wwa, "pdfwwa");
RooHistPdf* pdfwajets = makePdf(th1wajets, "pdfwajets");
RooHistPdf* pdfzajets = makePdf(th1zajets, "pdfzajets");
RooHistPdf* pdfTop = makePdf(th1Top, "pdfTop");
double fkNorm = th1fkdata->Integral();
double wwaNorm = th1wwa->Integral();
double wajetsNorm = th1wajets->Integral();
double zajetsNorm = th1zajets->Integral();
double TopNorm = th1Top->Integral();
RooRealVar nfk("nfk","nfk", fkNorm, 0.0, 1000.);
RooRealVar nwwa("nwwa","nwwa", wwaNorm);
RooRealVar nwajets("nwajets","nwajets", 400.0, 0.0, 10000.);
RooRealVar nzajets("nzajets","nzajets", zajetsNorm);
RooRealVar nTop("nTop","nTop", TopNorm);
RooArgList* components
= new RooArgList(*pdffk, *pdfwwa, *pdfwajets, *pdfzajets, *pdfTop);
RooArgList* yields = new RooArgList(nfk, nwwa, nwajets, nzajets, nTop);
RooAddPdf totalPdf("totalPdf","extended sum pdf", *components, *yields);
RooGaussian consNfk("consNfk","", nfk, RooConst(fkNorm),RooConst(0.146*fkNorm)) ;
RooGaussian consNwwa("consNwwa","", nwwa, RooConst(wwaNorm),RooConst(0.28*wwaNorm)) ;
RooGaussian consNzajets("consNzajets","", nzajets, RooConst(zajetsNorm),RooConst(0.22*zajetsNorm)) ;
RooGaussian consNTop("consNTop","", nTop, RooConst(TopNorm),RooConst(0.21*TopNorm)) ;
RooFitResult *fitResult
= totalPdf.fitTo(*data, Save(true),
ExternalConstraints(consNfk),
//ExternalConstraints(consNwwa),
//ExternalConstraints(consNzajets),
//ExternalConstraints(consNTop),
RooFit::Extended(true),
//RooFit::Minos(true),
//RooFit::Hesse(false),
//PrintEvalErrors(-1),
// RooFit::Range(rangeString),
Warnings(false)
);
fitResult->Print("v");
std::cout << "===================== Wa+jets k-factor = " <<
nwajets.getVal() / wajetsNorm << " +- " << nwajets.getError() / wajetsNorm << std::endl;
// ********** Make and save Canvas for the plots ********** //
gROOT->ProcessLine(".L ~kalanand/tdrstyle.C");
setTDRStyle();
tdrStyle->SetErrorX(0.5);
tdrStyle->SetPadLeftMargin(0.19);
tdrStyle->SetPadRightMargin(0.10);
tdrStyle->SetPadBottomMargin(0.15);
tdrStyle->SetLegendBorderSize(0);
tdrStyle->SetTitleYOffset(1.5);
RooAbsData::ErrorType errorType = RooAbsData::SumW2;
TCanvas* c = new TCanvas("fit","",500,500);
RooPlot* frame1 = Mass.frame();
data->plotOn(frame1,RooFit::DataError(errorType), Name("h_data"));
totalPdf.plotOn(frame1,ProjWData(*data), Name("h_total"));
totalPdf.plotOn(frame1,ProjWData(*data),Components("pdfwajets"),
LineColor(kRed), LineStyle(2), Name("h_wajets"));
totalPdf.plotOn(frame1,ProjWData(*data),Components("pdffk,pdfwwa,pdfzajets,pdfTop"),
LineColor(kBlack), LineStyle(2), Name("h_others"));
totalPdf.plotOn(frame1,ProjWData(*data));
frame1->SetMinimum(0);
frame1->SetMaximum(1.35* frame1->GetMaximum());
frame1->Draw("e0");
std::cout << "===================== chi2/ dof = " << frame1->chiSquare() << std::endl;
TPaveText *plotlabel4 = new TPaveText(0.25,0.66,0.5,0.81,"NDC");
plotlabel4->SetTextColor(kBlack);
plotlabel4->SetFillColor(kWhite);
plotlabel4->SetBorderSize(0);
plotlabel4->SetTextAlign(12);
plotlabel4->SetTextSize(0.04);
char temp[50];
sprintf(temp, "#chi^{2} / dof = %.2f", frame1->chiSquare());
plotlabel4->AddText(temp);
plotlabel4->Draw();
cmsPrelim2();
TLegend* legend = new TLegend(0.55,0.72,0.88,0.91);
RooHist* datahist = frame1->getHist("h_data");
RooCurve* totalhist = frame1->getCurve("h_total");
RooCurve* wjetshist = frame1->getCurve("h_wajets");
RooCurve* otherhist = frame1->getCurve("h_others");
legend->AddEntry( datahist, "Data", "PE");
legend->AddEntry( totalhist, "Fit", "L");
legend->AddEntry( wjetshist, "W#gamma+jets", "L");
legend->AddEntry( otherhist, "Other processes", "L");
legend->SetFillColor(0);
legend->Draw();
c->SaveAs( "el_WVa_WjetsKfactorFit.png");
c->SaveAs( "el_WVa_WjetsKfactorFit.pdf");
}
void TwoCategorySimZFitter( TH1& h_TT, TH1& h_TF,
double intLumi, int removeEE )
{
// The fit variable - lepton invariant mass
rooMass_ = new RooRealVar("Mass","m_{ee}",60.0, 120.0, "GeV/c^{2}");
rooMass_->setBins(20.0);
RooRealVar Mass = *rooMass_;
// Make the category variable that defines the two fits,
// namely whether the probe passes or fails the eff criteria.
RooCategory sample("sample","") ;
sample.defineType("TT", 1) ;
sample.defineType("TF", 2) ;
gROOT->cd();
///////// convert Histograms into RooDataHists
RooDataHist* data_TT = new RooDataHist("data_TT","data_TT",
RooArgList(Mass), &h_TT);
RooDataHist* data_TF = new RooDataHist("data_TF","data_TF",
RooArgList(Mass), &h_TF);
RooDataHist* data = new RooDataHist( "fitData","fitData",
RooArgList(Mass),Index(sample),
Import("TT",*data_TT), Import("TF",*data_TF) );
data->get()->Print();
cout << "Made datahist" << endl;
// ********** Construct signal & bkg shape PDF ********** //
makeSignalPdf();
cout << "Made signal pdf" << endl;
makeBkgPdf();
cout << "Made bkg pdf" << endl;
// Now supply integrated luminosity in inverse picobarn
// --> we get this number from the CMS lumi group
// https://twiki.cern.ch/twiki/bin/view/CMS/LumiWiki2010Data
RooRealVar lumi("lumi","lumi", intLumi);
// Now define Z production cross section variable (in pb)
RooRealVar xsec("xsec","xsec", 1300., 400.0, 2000.0);
// Define efficiency variables
RooRealVar eff("eff","eff", 0.9, 0.5, 1.0);
// Now define acceptance variables --> we get these numbers from MC
// RooRealVar acc_BB("acc_BB","acc_BB", 0.2253);
// RooRealVar acc_EB("acc_EB","acc_EB", 0.1625);
// RooRealVar acc_EE("acc_EE","acc_EE", 0.0479);
double ACCEPTANCE=0.4357;
if(removeEE==1) ACCEPTANCE= 0.3878;
if(removeEE==2) ACCEPTANCE= 0.2253;
RooRealVar acc("acc","acc", ACCEPTANCE);
// Define background yield variables: they are not related to each other
RooRealVar nBkgTF("nBkgTF","nBkgTF",10.,-10.,100000.);
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
// Define signal yield variables.
// They are linked together by the total cross section: e.g.
// Nbb = sigma*L*Abb*effB
char* formula;
RooArgList* args;
formula = "lumi*xsec*acc*eff*eff";
args = new RooArgList(lumi,xsec,acc,eff);
RooFormulaVar nSigTT("nSigTT", formula, *args);
delete args;
formula = "lumi*xsec*acc*eff*(1.0-eff)";
args = new RooArgList(lumi,xsec,acc,eff);
RooFormulaVar nSigTF("nSigTF",formula, *args);
delete args;
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
RooArgList componentsTF(*signalShapePdfTF_,*bkgShapePdfTF_);
RooArgList yieldsTF(nSigTF, nBkgTF );
RooExtendPdf pdfTT("pdfTT","extended sum pdf", *signalShapePdfTT_, nSigTT);
RooAddPdf pdfTF("pdfTF","extended sum pdf",componentsTF, yieldsTF);
// The total simultaneous fit ...
RooSimultaneous totalPdf("totalPdf","totalPdf", sample);
totalPdf.addPdf(pdfTT,"TT");
totalPdf.Print();
totalPdf.addPdf(pdfTF,"TF");
totalPdf.Print();
// ********* Do the Actual Fit ********** //
RooFitResult *fitResult = totalPdf.fitTo(*data, Save(true),
Extended(), Minos(),
PrintEvalErrors(-1),Warnings(false) );
fitResult->Print("v");
// ********** Make and save Canvas for the plots ********** //
gROOT->ProcessLine(".L ~/tdrstyle.C");
setTDRStyle();
tdrStyle->SetErrorX(0.5);
tdrStyle->SetPadLeftMargin(0.19);
tdrStyle->SetPadRightMargin(0.10);
tdrStyle->SetPadBottomMargin(0.15);
tdrStyle->SetLegendBorderSize(0);
tdrStyle->SetTitleYOffset(1.5);
RooAbsData::ErrorType errorType = RooAbsData::SumW2;
TString cname = Form("Zmass_TT_%dnb", (int)(1000*intLumi) );
c = new TCanvas(cname,cname,500,500);
RooPlot* frame1 = Mass.frame();
data_TT->plotOn(frame1,RooFit::DataError(errorType));
pdfTT.plotOn(frame1,ProjWData(*data_TT));
frame1->SetMinimum(0);
frame1->Draw("e0");
TPaveText *plotlabel = new TPaveText(0.23,0.87,0.43,0.92,"NDC");
plotlabel->SetTextColor(kBlack);
plotlabel->SetFillColor(kWhite);
plotlabel->SetBorderSize(0);
plotlabel->SetTextAlign(12);
plotlabel->SetTextSize(0.03);
plotlabel->AddText("CMS Preliminary 2010");
TPaveText *plotlabel2 = new TPaveText(0.23,0.82,0.43,0.87,"NDC");
plotlabel2->SetTextColor(kBlack);
plotlabel2->SetFillColor(kWhite);
plotlabel2->SetBorderSize(0);
plotlabel2->SetTextAlign(12);
plotlabel2->SetTextSize(0.03);
plotlabel2->AddText("#sqrt{s} = 7 TeV");
TPaveText *plotlabel3 = new TPaveText(0.23,0.75,0.43,0.80,"NDC");
plotlabel3->SetTextColor(kBlack);
plotlabel3->SetFillColor(kWhite);
plotlabel3->SetBorderSize(0);
plotlabel3->SetTextAlign(12);
plotlabel3->SetTextSize(0.03);
char temp[100];
sprintf(temp, "%.1f", intLumi);
plotlabel3->AddText((string("#int#font[12]{L}dt = ") +
temp + string(" pb^{ -1}")).c_str());
TPaveText *plotlabel4 = new TPaveText(0.6,0.87,0.8,0.92,"NDC");
plotlabel4->SetTextColor(kBlack);
plotlabel4->SetFillColor(kWhite);
plotlabel4->SetBorderSize(0);
plotlabel4->SetTextAlign(12);
plotlabel4->SetTextSize(0.03);
double nsig = eff.getVal()*xsec.getVal()*acc.getVal()*lumi.getVal();
double xsecFrErr = xsec.getError()/xsec.getVal();
double effFrErr = eff.getError()/eff.getVal();
double effxsecCorr = fitResult->correlation(eff, xsec);
double nsigerr = sqrt(effFrErr**2 +xsecFrErr**2 +
2.0*effxsecCorr*xsecFrErr*effFrErr)*nsig;
sprintf(temp, "Signal = %.2f #pm %.2f", nsig, nsigerr);
plotlabel4->AddText(temp);
TPaveText *plotlabel5 = new TPaveText(0.6,0.82,0.8,0.87,"NDC");
plotlabel5->SetTextColor(kBlack);
plotlabel5->SetFillColor(kWhite);
plotlabel5->SetBorderSize(0);
plotlabel5->SetTextAlign(12);
plotlabel5->SetTextSize(0.03);
sprintf(temp, "#epsilon = %.4f #pm %.4f", eff.getVal(), eff.getError());
plotlabel5->AddText(temp);
TPaveText *plotlabel6 = new TPaveText(0.6,0.77,0.8,0.82,"NDC");
plotlabel6->SetTextColor(kBlack);
plotlabel6->SetFillColor(kWhite);
plotlabel6->SetBorderSize(0);
plotlabel6->SetTextAlign(12);
plotlabel6->SetTextSize(0.03);
sprintf(temp, "#sigma = %.1f #pm %.1f pb", xsec.getVal(), xsec.getError());
plotlabel6->AddText(temp);
plotlabel->Draw();
plotlabel2->Draw();
plotlabel3->Draw();
plotlabel4->Draw();
plotlabel5->Draw();
plotlabel6->Draw();
c->SaveAs( cname + TString(".eps"));
c->SaveAs( cname + TString(".gif"));
c->SaveAs( cname + TString(".root"));
c->SaveAs( cname + TString(".png"));
c->SaveAs( cname + TString(".C"));
TString cname = Form("Zmass_TF_%dnb", (int)(1000*intLumi) );
c = new TCanvas(cname,cname,500,500);
RooPlot* frame2 = Mass.frame();
data_TF->plotOn(frame2,RooFit::DataError(errorType));
pdfTF.plotOn(frame2,ProjWData(*data_TF),
Components(*bkgShapePdfTF_),LineColor(kRed));
pdfTF.plotOn(frame2,ProjWData(*data_TF));
frame2->SetMinimum(0);
frame2->Draw("e0");
frame2->GetYaxis()->SetNdivisions(505);
TPaveText *plotlabel = new TPaveText(0.23,0.87,0.43,0.92,"NDC");
plotlabel->SetTextColor(kBlack);
plotlabel->SetFillColor(kWhite);
plotlabel->SetBorderSize(0);
plotlabel->SetTextAlign(12);
plotlabel->SetTextSize(0.03);
plotlabel->AddText("CMS Preliminary 2010");
TPaveText *plotlabel2 = new TPaveText(0.23,0.82,0.43,0.87,"NDC");
plotlabel2->SetTextColor(kBlack);
plotlabel2->SetFillColor(kWhite);
plotlabel2->SetBorderSize(0);
plotlabel2->SetTextAlign(12);
plotlabel2->SetTextSize(0.03);
plotlabel2->AddText("#sqrt{s} = 7 TeV");
TPaveText *plotlabel3 = new TPaveText(0.23,0.75,0.43,0.80,"NDC");
plotlabel3->SetTextColor(kBlack);
plotlabel3->SetFillColor(kWhite);
plotlabel3->SetBorderSize(0);
plotlabel3->SetTextAlign(12);
plotlabel3->SetTextSize(0.03);
char temp[100];
sprintf(temp, "%.1f", intLumi);
plotlabel3->AddText((string("#int#font[12]{L}dt = ") +
temp + string(" pb^{ -1}")).c_str());
TPaveText *plotlabel4 = new TPaveText(0.6,0.87,0.8,0.92,"NDC");
plotlabel4->SetTextColor(kBlack);
plotlabel4->SetFillColor(kWhite);
plotlabel4->SetBorderSize(0);
plotlabel4->SetTextAlign(12);
plotlabel4->SetTextSize(0.03);
double nsig = (1.0-eff.getVal())*xsec.getVal()*acc.getVal()*lumi.getVal();
double xsecFrErr = xsec.getError()/xsec.getVal();
double effFrErr = eff.getError()/(1.0-eff.getVal());
double effxsecCorr = fitResult->correlation(eff, xsec);
double nsigerr = sqrt(effFrErr**2 +xsecFrErr**2 +
2.0*effxsecCorr*xsecFrErr*effFrErr)*nsig;
sprintf(temp, "Signal = %.2f #pm %.2f", nsig, nsigerr);
plotlabel4->AddText(temp);
TPaveText *plotlabel5 = new TPaveText(0.6,0.82,0.8,0.87,"NDC");
plotlabel5->SetTextColor(kBlack);
plotlabel5->SetFillColor(kWhite);
plotlabel5->SetBorderSize(0);
plotlabel5->SetTextAlign(12);
plotlabel5->SetTextSize(0.03);
sprintf(temp, "Bkg = %.2f #pm %.2f", nBkgTF.getVal(), nBkgTF.getError());
plotlabel5->AddText(temp);
TPaveText *plotlabel6 = new TPaveText(0.6,0.77,0.8,0.82,"NDC");
plotlabel6->SetTextColor(kBlack);
plotlabel6->SetFillColor(kWhite);
plotlabel6->SetBorderSize(0);
plotlabel6->SetTextAlign(12);
plotlabel6->SetTextSize(0.03);
sprintf(temp, "#epsilon = %.4f #pm %.4f", eff.getVal(), eff.getError());
plotlabel6->AddText(temp);
plotlabel->Draw();
plotlabel2->Draw();
plotlabel3->Draw();
plotlabel4->Draw();
plotlabel5->Draw();
plotlabel6->Draw();
c->SaveAs( cname + TString(".eps"));
c->SaveAs( cname + TString(".gif"));
c->SaveAs( cname + TString(".root"));
c->SaveAs( cname + TString(".png"));
c->SaveAs( cname + TString(".C"));
/*
RooMCStudy toymc( totalPdf, RooArgSet(Mass, sample), Binned(kTRUE),
FitModel(totalPdf), Extended(),FitOptions(Extended(), Minos()));
int numEventsToGenerate = (int)(h_TT.Integral()+h_TF.Integral());
toymc.generateAndFit(1000,numEventsToGenerate);
RooPlot* plot1 = toymc.plotPull( xsec, -4., 4., 24);
plot1->SetTitle("");
plot1->GetXaxis()->SetTitle("cross section pull");
TString cname = Form("pull_crosssection_%dnb", (int)(1000*intLumi));
TCanvas *c2 = new TCanvas(cname,"Pull distribution of cross section",500,500);
plot1->Draw();
c2->SaveAs( cname + TString(".eps"));
c2->SaveAs( cname + TString(".gif"));
c2->SaveAs( cname + TString(".root"));
RooPlot* plot2 = toymc.plotError( eff, 0., 0.2, 20);
plot2->SetTitle("");
plot2->GetXaxis()->SetTitle("Uncertainty in efficiency");
TString cname = Form("error_efficiency_%dnb", (int)(1000*intLumi));
TCanvas *c3 = new TCanvas(cname,"Uncertainty in efficiency",500,500);
plot2->Draw();
c3->SaveAs( cname + TString(".eps"));
c3->SaveAs( cname + TString(".gif"));
c3->SaveAs( cname + TString(".root"));
RooPlot* plot3 = toymc.plotError( xsec, 0., 650., 65);
plot3->SetTitle("");
plot3->GetXaxis()->SetTitle("Uncertainty in cross section (pb)");
TString cname = Form("error_crosssection_%dnb", (int)(1000*intLumi));
TCanvas *c4 = new TCanvas(cname,"Uncertainty in cross section",500,500);
plot3->Draw();
c4->SaveAs( cname + TString(".eps"));
c4->SaveAs( cname + TString(".gif"));
c4->SaveAs( cname + TString(".root"));
*/
// if(data) delete data;
// if(c) delete c;
}
void StandardBayesianNumericalDemo(const char* infile = "",
const char* workspaceName = "combined",
const char* modelConfigName = "ModelConfig",
const char* dataName = "obsData") {
// option definitions
double confLevel = optBayes.confLevel;
TString integrationType = optBayes.integrationType;
int nToys = optBayes.nToys;
bool scanPosterior = optBayes.scanPosterior;
int nScanPoints = optBayes.nScanPoints;
int intervalType = optBayes.intervalType;
int maxPOI = optBayes.maxPOI;
double nSigmaNuisance = optBayes.nSigmaNuisance;
/////////////////////////////////////////////////////////////
// First part is just to access a user-defined file
// or create the standard example file if it doesn't exist
////////////////////////////////////////////////////////////
const char* filename = "";
if (!strcmp(infile,"")) {
filename = "results/example_combined_GaussExample_model.root";
bool fileExist = !gSystem->AccessPathName(filename); // note opposite return code
// if file does not exists generate with histfactory
if (!fileExist) {
#ifdef _WIN32
cout << "HistFactory file cannot be generated on Windows - exit" << endl;
return;
#endif
// Normally this would be run on the command line
cout <<"will run standard hist2workspace example"<<endl;
gROOT->ProcessLine(".! prepareHistFactory .");
gROOT->ProcessLine(".! hist2workspace config/example.xml");
cout <<"\n\n---------------------"<<endl;
cout <<"Done creating example input"<<endl;
cout <<"---------------------\n\n"<<endl;
}
}
else
filename = infile;
// Try to open the file
TFile *file = TFile::Open(filename);
// if input file was specified byt not found, quit
if(!file ){
cout <<"StandardRooStatsDemoMacro: Input file " << filename << " is not found" << endl;
return;
}
/////////////////////////////////////////////////////////////
// Tutorial starts here
////////////////////////////////////////////////////////////
// get the workspace out of the file
RooWorkspace* w = (RooWorkspace*) file->Get(workspaceName);
if(!w){
cout <<"workspace not found" << endl;
return;
}
// get the modelConfig out of the file
ModelConfig* mc = (ModelConfig*) w->obj(modelConfigName);
// get the modelConfig out of the file
RooAbsData* data = w->data(dataName);
// make sure ingredients are found
if(!data || !mc){
w->Print();
cout << "data or ModelConfig was not found" <<endl;
return;
}
/////////////////////////////////////////////
// create and use the BayesianCalculator
// to find and plot the 95% credible interval
// on the parameter of interest as specified
// in the model config
// before we do that, we must specify our prior
// it belongs in the model config, but it may not have
// been specified
RooUniform prior("prior","",*mc->GetParametersOfInterest());
w->import(prior);
mc->SetPriorPdf(*w->pdf("prior"));
// do without systematics
//mc->SetNuisanceParameters(RooArgSet() );
if (nSigmaNuisance > 0) {
RooAbsPdf * pdf = mc->GetPdf();
assert(pdf);
RooFitResult * res = pdf->fitTo(*data, Save(true), Minimizer(ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_str()), Hesse(true),
PrintLevel(ROOT::Math::MinimizerOptions::DefaultPrintLevel()-1) );
res->Print();
RooArgList nuisPar(*mc->GetNuisanceParameters());
for (int i = 0; i < nuisPar.getSize(); ++i) {
RooRealVar * v = dynamic_cast<RooRealVar*> (&nuisPar[i] );
assert( v);
v->setMin( TMath::Max( v->getMin(), v->getVal() - nSigmaNuisance * v->getError() ) );
v->setMax( TMath::Min( v->getMax(), v->getVal() + nSigmaNuisance * v->getError() ) );
std::cout << "setting interval for nuisance " << v->GetName() << " : [ " << v->getMin() << " , " << v->getMax() << " ]" << std::endl;
}
}
BayesianCalculator bayesianCalc(*data,*mc);
bayesianCalc.SetConfidenceLevel(confLevel); // 95% interval
// default of the calculator is central interval. here use shortest , central or upper limit depending on input
// doing a shortest interval might require a longer time since it requires a scan of the posterior function
if (intervalType == 0) bayesianCalc.SetShortestInterval(); // for shortest interval
if (intervalType == 1) bayesianCalc.SetLeftSideTailFraction(0.5); // for central interval
if (intervalType == 2) bayesianCalc.SetLeftSideTailFraction(0.); // for upper limit
if (!integrationType.IsNull() ) {
bayesianCalc.SetIntegrationType(integrationType); // set integrationType
bayesianCalc.SetNumIters(nToys); // set number of ietrations (i.e. number of toys for MC integrations)
}
// in case of toyMC make a nnuisance pdf
if (integrationType.Contains("TOYMC") ) {
RooAbsPdf * nuisPdf = RooStats::MakeNuisancePdf(*mc, "nuisance_pdf");
cout << "using TOYMC integration: make nuisance pdf from the model " << std::endl;
nuisPdf->Print();
bayesianCalc.ForceNuisancePdf(*nuisPdf);
scanPosterior = true; // for ToyMC the posterior is scanned anyway so used given points
}
// compute interval by scanning the posterior function
if (scanPosterior)
bayesianCalc.SetScanOfPosterior(nScanPoints);
RooRealVar* poi = (RooRealVar*) mc->GetParametersOfInterest()->first();
if (maxPOI != -999 && maxPOI > poi->getMin())
poi->setMax(maxPOI);
SimpleInterval* interval = bayesianCalc.GetInterval();
// print out the iterval on the first Parameter of Interest
cout << "\n>>>> RESULT : " << confLevel*100 << "% interval on " << poi->GetName()<<" is : ["<<
interval->LowerLimit() << ", "<<
interval->UpperLimit() <<"] "<<endl;
// make a plot
// since plotting may take a long time (it requires evaluating
// the posterior in many points) this command will speed up
// by reducing the number of points to plot - do 50
// ignore errors of PDF if is zero
RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::Ignore) ;
cout << "\nDrawing plot of posterior function....." << endl;
// always plot using numer of scan points
bayesianCalc.SetScanOfPosterior(nScanPoints);
RooPlot * plot = bayesianCalc.GetPosteriorPlot();
plot->Draw();
}
void constrained_scan( const char* wsfile = "outputfiles/ws.root",
const char* new_poi_name="mu_bg_4b_msig_met1",
double constraintWidth=1.5,
int npoiPoints = 20,
double poiMinVal = 0.,
double poiMaxVal = 10.0,
double ymax = 9.,
int verbLevel=1 ) {
TString outputdir("outputfiles") ;
gStyle->SetOptStat(0) ;
TFile* wstf = new TFile( wsfile ) ;
RooWorkspace* ws = dynamic_cast<RooWorkspace*>( wstf->Get("ws") );
ws->Print() ;
RooDataSet* rds = (RooDataSet*) ws->obj( "hbb_observed_rds" ) ;
cout << "\n\n\n ===== RooDataSet ====================\n\n" << endl ;
rds->Print() ;
rds->printMultiline(cout, 1, kTRUE, "") ;
RooRealVar* rv_sig_strength = ws->var("sig_strength") ;
if ( rv_sig_strength == 0x0 ) { printf("\n\n *** can't find sig_strength in workspace.\n\n" ) ; return ; }
RooAbsPdf* likelihood = ws->pdf("likelihood") ;
if ( likelihood == 0x0 ) { printf("\n\n *** can't find likelihood in workspace.\n\n" ) ; return ; }
printf("\n\n Likelihood:\n") ;
likelihood -> Print() ;
/////rv_sig_strength -> setConstant( kFALSE ) ;
rv_sig_strength -> setVal(0.) ;
rv_sig_strength -> setConstant( kTRUE ) ;
likelihood->fitTo( *rds, Save(false), PrintLevel(0), Hesse(true), Strategy(1) ) ;
//RooFitResult* fitResult = likelihood->fitTo( *rds, Save(true), PrintLevel(0), Hesse(true), Strategy(1) ) ;
//double minNllSusyFloat = fitResult->minNll() ;
//double susy_ss_atMinNll = rv_sig_strength -> getVal() ;
RooMsgService::instance().getStream(1).removeTopic(Minimization) ;
RooMsgService::instance().getStream(1).removeTopic(Fitting) ;
//-- Construct the new POI parameter.
RooAbsReal* new_poi_rar(0x0) ;
new_poi_rar = ws->var( new_poi_name ) ;
if ( new_poi_rar == 0x0 ) {
printf("\n\n New POI %s is not a variable. Trying function.\n\n", new_poi_name ) ;
new_poi_rar = ws->function( new_poi_name ) ;
if ( new_poi_rar == 0x0 ) {
printf("\n\n New POI %s is not a function. I quit.\n\n", new_poi_name ) ;
return ;
} else {
printf("\n Found it.\n\n") ;
}
} else {
printf("\n\n New POI %s is a variable with current value %.1f.\n\n", new_poi_name, new_poi_rar->getVal() ) ;
}
double startPoiVal = new_poi_rar->getVal() ;
RooAbsReal* nll = likelihood -> createNLL( *rds, Verbose(true) ) ;
RooRealVar* rrv_poiValue = new RooRealVar( "poiValue", "poiValue", 0., -10000., 10000. ) ;
RooRealVar* rrv_constraintWidth = new RooRealVar("constraintWidth","constraintWidth", 0.1, 0.1, 1000. ) ;
rrv_constraintWidth -> setVal( constraintWidth ) ;
rrv_constraintWidth -> setConstant(kTRUE) ;
RooMinuit* rminuit( 0x0 ) ;
RooMinuit* rminuit_uc = new RooMinuit( *nll ) ;
rminuit_uc->setPrintLevel(verbLevel-1) ;
rminuit_uc->setNoWarn() ;
rminuit_uc->migrad() ;
rminuit_uc->hesse() ;
RooFitResult* rfr_uc = rminuit_uc->fit("mr") ;
double floatParInitVal[10000] ;
char floatParName[10000][100] ;
int nFloatParInitVal(0) ;
RooArgList ral_floats = rfr_uc->floatParsFinal() ;
TIterator* floatParIter = ral_floats.createIterator() ;
{
RooRealVar* par ;
while ( (par = (RooRealVar*) floatParIter->Next()) ) {
sprintf( floatParName[nFloatParInitVal], "%s", par->GetName() ) ;
floatParInitVal[nFloatParInitVal] = par->getVal() ;
nFloatParInitVal++ ;
}
}
printf("\n\n Unbiased best value for new POI %s is : %7.1f\n\n", new_poi_rar->GetName(), new_poi_rar->getVal() ) ;
double best_poi_val = new_poi_rar->getVal() ;
char minuit_formula[10000] ;
sprintf( minuit_formula, "%s+%s*(%s-%s)*(%s-%s)",
nll->GetName(),
rrv_constraintWidth->GetName(),
new_poi_rar->GetName(), rrv_poiValue->GetName(),
new_poi_rar->GetName(), rrv_poiValue->GetName()
) ;
printf("\n\n Creating new minuit variable with formula: %s\n\n", minuit_formula ) ;
RooFormulaVar* new_minuit_var = new RooFormulaVar("new_minuit_var", minuit_formula,
RooArgList( *nll,
*rrv_constraintWidth,
*new_poi_rar, *rrv_poiValue,
*new_poi_rar, *rrv_poiValue
) ) ;
printf("\n\n Current value is %.2f\n\n",
new_minuit_var->getVal() ) ;
rminuit = new RooMinuit( *new_minuit_var ) ;
RooAbsReal* plot_var = nll ;
printf("\n\n Current value is %.2f\n\n",
plot_var->getVal() ) ;
rminuit->setPrintLevel(verbLevel-1) ;
if ( verbLevel <=0 ) { rminuit->setNoWarn() ; }
if ( poiMinVal < 0. && poiMaxVal < 0. ) {
printf("\n\n Automatic determination of scan range.\n\n") ;
if ( startPoiVal <= 0. ) {
printf("\n\n *** POI starting value zero or negative %g. Quit.\n\n\n", startPoiVal ) ;
return ;
}
poiMinVal = startPoiVal - 3.5 * sqrt(startPoiVal) ;
poiMaxVal = startPoiVal + 6.0 * sqrt(startPoiVal) ;
if ( poiMinVal < 0. ) { poiMinVal = 0. ; }
printf(" Start val = %g. Scan range: %g to %g\n\n", startPoiVal, poiMinVal, poiMaxVal ) ;
}
//----------------------------------------------------------------------------------------------
double poiVals_scanDown[1000] ;
double nllVals_scanDown[1000] ;
//-- Do scan down from best value.
printf("\n\n +++++ Starting scan down from best value.\n\n") ;
double minNllVal(1.e9) ;
for ( int poivi=0; poivi < npoiPoints/2 ; poivi++ ) {
////double poiValue = poiMinVal + poivi*(poiMaxVal-poiMinVal)/(1.*(npoiPoints-1)) ;
double poiValue = best_poi_val - poivi*(best_poi_val-poiMinVal)/(1.*(npoiPoints/2-1)) ;
rrv_poiValue -> setVal( poiValue ) ;
rrv_poiValue -> setConstant( kTRUE ) ;
//+++++++++++++++++++++++++++++++++++
rminuit->migrad() ;
rminuit->hesse() ;
RooFitResult* rfr = rminuit->save() ;
//+++++++++++++++++++++++++++++++++++
if ( verbLevel > 0 ) { rfr->Print("v") ; }
float fit_minuit_var_val = rfr->minNll() ;
printf(" %02d : poi constraint = %.2f : allvars : MinuitVar, createNLL, PV, POI : %.5f %.5f %.5f %.5f\n",
poivi, rrv_poiValue->getVal(), fit_minuit_var_val, nll->getVal(), plot_var->getVal(), new_poi_rar->getVal() ) ;
cout << flush ;
poiVals_scanDown[poivi] = new_poi_rar->getVal() ;
nllVals_scanDown[poivi] = plot_var->getVal() ;
if ( nllVals_scanDown[poivi] < minNllVal ) { minNllVal = nllVals_scanDown[poivi] ; }
delete rfr ;
} // poivi
printf("\n\n +++++ Resetting floats to best fit values.\n\n") ;
for ( int pi=0; pi<nFloatParInitVal; pi++ ) {
RooRealVar* par = ws->var( floatParName[pi] ) ;
par->setVal( floatParInitVal[pi] ) ;
} // pi.
printf("\n\n +++++ Starting scan up from best value.\n\n") ;
//-- Now do scan up.
double poiVals_scanUp[1000] ;
double nllVals_scanUp[1000] ;
for ( int poivi=0; poivi < npoiPoints/2 ; poivi++ ) {
double poiValue = best_poi_val + poivi*(poiMaxVal-best_poi_val)/(1.*(npoiPoints/2-1)) ;
rrv_poiValue -> setVal( poiValue ) ;
rrv_poiValue -> setConstant( kTRUE ) ;
//+++++++++++++++++++++++++++++++++++
rminuit->migrad() ;
rminuit->hesse() ;
RooFitResult* rfr = rminuit->save() ;
//+++++++++++++++++++++++++++++++++++
if ( verbLevel > 0 ) { rfr->Print("v") ; }
float fit_minuit_var_val = rfr->minNll() ;
printf(" %02d : poi constraint = %.2f : allvars : MinuitVar, createNLL, PV, POI : %.5f %.5f %.5f %.5f\n",
poivi, rrv_poiValue->getVal(), fit_minuit_var_val, nll->getVal(), plot_var->getVal(), new_poi_rar->getVal() ) ;
cout << flush ;
poiVals_scanUp[poivi] = new_poi_rar->getVal() ;
nllVals_scanUp[poivi] = plot_var->getVal() ;
if ( nllVals_scanUp[poivi] < minNllVal ) { minNllVal = nllVals_scanUp[poivi] ; }
delete rfr ;
} // poivi
double poiVals[1000] ;
double nllVals[1000] ;
int pointCount(0) ;
for ( int pi=0; pi<npoiPoints/2; pi++ ) {
poiVals[pi] = poiVals_scanDown[(npoiPoints/2-1)-pi] ;
nllVals[pi] = nllVals_scanDown[(npoiPoints/2-1)-pi] ;
pointCount++ ;
}
for ( int pi=1; pi<npoiPoints/2; pi++ ) {
poiVals[pointCount] = poiVals_scanUp[pi] ;
nllVals[pointCount] = nllVals_scanUp[pi] ;
pointCount++ ;
}
npoiPoints = pointCount ;
printf("\n\n --- TGraph arrays:\n") ;
for ( int i=0; i<npoiPoints; i++ ) {
printf(" %2d : poi = %6.1f, nll = %g\n", i, poiVals[i], nllVals[i] ) ;
}
printf("\n\n") ;
double nllDiffVals[1000] ;
double poiAtMinlnL(-1.) ;
double poiAtMinusDelta2(-1.) ;
double poiAtPlusDelta2(-1.) ;
for ( int poivi=0; poivi < npoiPoints ; poivi++ ) {
nllDiffVals[poivi] = 2.*(nllVals[poivi] - minNllVal) ;
double poiValue = poiMinVal + poivi*(poiMaxVal-poiMinVal)/(1.*npoiPoints) ;
if ( nllDiffVals[poivi] < 0.01 ) { poiAtMinlnL = poiValue ; }
if ( poiAtMinusDelta2 < 0. && nllDiffVals[poivi] < 2.5 ) { poiAtMinusDelta2 = poiValue ; }
if ( poiAtMinlnL > 0. && poiAtPlusDelta2 < 0. && nllDiffVals[poivi] > 2.0 ) { poiAtPlusDelta2 = poiValue ; }
} // poivi
printf("\n\n Estimates for poi at delta ln L = -2, 0, +2: %g , %g , %g\n\n", poiAtMinusDelta2, poiAtMinlnL, poiAtPlusDelta2 ) ;
//--- Main canvas
TCanvas* cscan = (TCanvas*) gDirectory->FindObject("cscan") ;
if ( cscan == 0x0 ) {
printf("\n Creating canvas.\n\n") ;
cscan = new TCanvas("cscan","Delta nll") ;
}
char gname[1000] ;
TGraph* graph = new TGraph( npoiPoints, poiVals, nllDiffVals ) ;
sprintf( gname, "scan_%s", new_poi_name ) ;
graph->SetName( gname ) ;
double poiBest(-1.) ;
double poiMinus1stdv(-1.) ;
double poiPlus1stdv(-1.) ;
double poiMinus2stdv(-1.) ;
double poiPlus2stdv(-1.) ;
double twoDeltalnLMin(1e9) ;
int nscan(1000) ;
for ( int xi=0; xi<nscan; xi++ ) {
double x = poiVals[0] + xi*(poiVals[npoiPoints-1]-poiVals[0])/(nscan-1) ;
double twoDeltalnL = graph -> Eval( x, 0, "S" ) ;
if ( poiMinus1stdv < 0. && twoDeltalnL < 1.0 ) { poiMinus1stdv = x ; printf(" set m1 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;}
if ( poiMinus2stdv < 0. && twoDeltalnL < 4.0 ) { poiMinus2stdv = x ; printf(" set m2 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;}
if ( twoDeltalnL < twoDeltalnLMin ) { poiBest = x ; twoDeltalnLMin = twoDeltalnL ; }
if ( twoDeltalnLMin < 0.3 && poiPlus1stdv < 0. && twoDeltalnL > 1.0 ) { poiPlus1stdv = x ; printf(" set p1 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;}
if ( twoDeltalnLMin < 0.3 && poiPlus2stdv < 0. && twoDeltalnL > 4.0 ) { poiPlus2stdv = x ; printf(" set p2 : %d, x=%g, 2dnll=%g\n", xi, x, twoDeltalnL) ;}
if ( xi%100 == 0 ) { printf( " %4d : poi=%6.2f, 2DeltalnL = %6.2f\n", xi, x, twoDeltalnL ) ; }
}
printf("\n\n POI estimate : %g +%g -%g [%g,%g], two sigma errors: +%g -%g [%g,%g]\n\n",
poiBest,
(poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv), poiMinus1stdv, poiPlus1stdv,
(poiPlus2stdv-poiBest), (poiBest-poiMinus2stdv), poiMinus2stdv, poiPlus2stdv
) ;
printf(" %s val,pm1sig,pm2sig: %7.2f %7.2f %7.2f %7.2f %7.2f\n",
new_poi_name, poiBest, (poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv), (poiPlus2stdv-poiBest), (poiBest-poiMinus2stdv) ) ;
char htitle[1000] ;
sprintf(htitle, "%s profile likelihood scan: -2ln(L/Lm)", new_poi_name ) ;
TH1F* hscan = new TH1F("hscan", htitle, 10, poiMinVal, poiMaxVal ) ;
hscan->SetMinimum(0.) ;
hscan->SetMaximum(ymax) ;
hscan->DrawCopy() ;
graph->SetLineColor(4) ;
graph->SetLineWidth(3) ;
graph->Draw("CP") ;
gPad->SetGridx(1) ;
gPad->SetGridy(1) ;
cscan->Update() ;
TLine* line = new TLine() ;
line->SetLineColor(2) ;
line->DrawLine(poiMinVal, 1., poiPlus1stdv, 1.) ;
line->DrawLine(poiMinus1stdv,0., poiMinus1stdv, 1.) ;
line->DrawLine(poiPlus1stdv ,0., poiPlus1stdv , 1.) ;
TText* text = new TText() ;
text->SetTextSize(0.04) ;
char tstring[1000] ;
sprintf( tstring, "%s = %.1f +%.1f -%.1f", new_poi_name, poiBest, (poiPlus1stdv-poiBest), (poiBest-poiMinus1stdv) ) ;
text -> DrawTextNDC( 0.15, 0.85, tstring ) ;
sprintf( tstring, "68%% interval [%.1f, %.1f]", poiMinus1stdv, poiPlus1stdv ) ;
text -> DrawTextNDC( 0.15, 0.78, tstring ) ;
char hname[1000] ;
sprintf( hname, "hscanout_%s", new_poi_name ) ;
TH1F* hsout = new TH1F( hname,"scan results",4,0.,4.) ;
double obsVal(-1.) ;
hsout->SetBinContent(1, obsVal ) ;
hsout->SetBinContent(2, poiPlus1stdv ) ;
hsout->SetBinContent(3, poiBest ) ;
hsout->SetBinContent(4, poiMinus1stdv ) ;
TAxis* xaxis = hsout->GetXaxis() ;
xaxis->SetBinLabel(1,"Observed val.") ;
xaxis->SetBinLabel(2,"Model+1sd") ;
xaxis->SetBinLabel(3,"Model") ;
xaxis->SetBinLabel(4,"Model-1sd") ;
char outrootfile[10000] ;
sprintf( outrootfile, "%s/scan-ff-%s.root", outputdir.Data(), new_poi_name ) ;
char outpdffile[10000] ;
sprintf( outpdffile, "%s/scan-ff-%s.pdf", outputdir.Data(), new_poi_name ) ;
cscan->Update() ; cscan->Draw() ;
printf("\n Saving %s\n", outpdffile ) ;
cscan->SaveAs( outpdffile ) ;
//--- save in root file
printf("\n Saving %s\n", outrootfile ) ;
TFile fout(outrootfile,"recreate") ;
graph->Write() ;
hsout->Write() ;
fout.Close() ;
delete ws ;
wstf->Close() ;
} // constrained_scan.
