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.