void Plot(RooAbsPdf *iGen,RooAbsPdf *iFit,int iN,int iNEvents,RooRealVar &iVar,RooRealVar &iSig,RooRealVar &iMean, RooRealVar &iScale,RooRealVar &iRes,RooDataSet *iData=0) { TRandom1 *lRand = new TRandom1(0xDEADBEEF); RooDataSet * lSignal = iGen->generate(iVar,iNEvents); if(iData == 0) { iFit->fitTo(*lSignal,Strategy(1)); if(iMean.getError() < 0.05) iFit->fitTo(*lSignal,Strategy(2)); } else { iFit->fitTo(*iData,Strategy(1)); if(iMean.getError() < 0.05) iFit->fitTo(*iData,Strategy(2)); } iVar.setBins(30); RooPlot *lFrame1 = iVar.frame(RooFit::Title("XXX")) ; if(iData == 0) lSignal->plotOn(lFrame1); if(iData != 0) iData->plotOn(lFrame1); iFit->plotOn(lFrame1); TCanvas *iC =new TCanvas("A","A",800,600); iC->cd(); lFrame1->Draw(); iC->SaveAs("Crap.png"); if(iData != 0) { RooPlot *lFrame2 = iVar.frame(RooFit::Title("XXX")) ; iData->plotOn(lFrame2); iGen->plotOn(lFrame2); TCanvas *iC1 =new TCanvas("B","B",800,600); iC1->cd(); lFrame2->Draw(); iC1->SaveAs("Crap.png"); } }
void FitterUtils::PlotShape2D(RooDataSet& originDataSet, RooDataSet& genDataSet, RooAbsPdf& shape, string plotsfile, string canvName, RooRealVar& B_plus_M, RooRealVar& misPT) { //**************Prepare TFile to save the plots TFile f2(plotsfile.c_str(), "UPDATE"); //**************Plot Signal Zero Gamma TH2F* th2fKey = (TH2F*)shape.createHistogram("th2Shape", B_plus_M, Binning(20), YVar(misPT, Binning(20))); cout<<genDataSet.sumEntries()<<endl; TH2F* th2fGen = (TH2F*)genDataSet.createHistogram("th2fGen", B_plus_M, Binning(20), YVar(misPT, Binning(20))); RooPlot* plotM = B_plus_M.frame(); originDataSet.plotOn(plotM); shape.plotOn(plotM); RooPlot* plotMisPT = misPT.frame(); originDataSet.plotOn(plotMisPT); shape.plotOn(plotMisPT); TCanvas canv(canvName.c_str(), canvName.c_str(), 800, 800); canv.Divide(2,2); canv.cd(1); th2fGen->Draw("lego"); canv.cd(2); th2fKey->Draw("surf"); canv.cd(3); plotM->Draw(); canv.cd(4); plotMisPT->Draw(); canv.Write(); f2.Close(); }
//____________________________________ void MakePlots(RooWorkspace* wks) { // Make plots of the data and the best fit model in two cases: // first the signal+background case // second the background-only case. // get some things out of workspace RooAbsPdf* model = wks->pdf("model"); RooAbsPdf* sigModel = wks->pdf("sigModel"); RooAbsPdf* zjjModel = wks->pdf("zjjModel"); RooAbsPdf* qcdModel = wks->pdf("qcdModel"); RooRealVar* mu = wks->var("mu"); RooRealVar* invMass = wks->var("invMass"); RooAbsData* data = wks->data("data"); ////////////////////////////////////////////////////////// // Make plots for the Alternate hypothesis, eg. let mu float mu->setConstant(kFALSE); model->fitTo(*data,Save(kTRUE),Minos(kFALSE), Hesse(kFALSE),PrintLevel(-1)); //plot sig candidates, full model, and individual componenets new TCanvas(); RooPlot* frame = invMass->frame() ; data->plotOn(frame ) ; model->plotOn(frame) ; model->plotOn(frame,Components(*sigModel),LineStyle(kDashed), LineColor(kRed)) ; model->plotOn(frame,Components(*zjjModel),LineStyle(kDashed),LineColor(kBlack)) ; model->plotOn(frame,Components(*qcdModel),LineStyle(kDashed),LineColor(kGreen)) ; frame->SetTitle("An example fit to the signal + background model"); frame->Draw() ; // cdata->SaveAs("alternateFit.gif"); ////////////////////////////////////////////////////////// // Do Fit to the Null hypothesis. Eg. fix mu=0 mu->setVal(0); // set signal fraction to 0 mu->setConstant(kTRUE); // set constant model->fitTo(*data, Save(kTRUE), Minos(kFALSE), Hesse(kFALSE),PrintLevel(-1)); // plot signal candidates with background model and components new TCanvas(); RooPlot* xframe2 = invMass->frame() ; data->plotOn(xframe2, DataError(RooAbsData::SumW2)) ; model->plotOn(xframe2) ; model->plotOn(xframe2, Components(*zjjModel),LineStyle(kDashed),LineColor(kBlack)) ; model->plotOn(xframe2, Components(*qcdModel),LineStyle(kDashed),LineColor(kGreen)) ; xframe2->SetTitle("An example fit to the background-only model"); xframe2->Draw() ; // cbkgonly->SaveAs("nullFit.gif"); }
void ComputeUpperLimit(RooAbsData *data, RooStats::ModelConfig *model, float &UpperLimit, float &signif, RooRealVar *mu, RooArgSet *nullParams,RooWorkspace *ws,REGION region,const char* tag) { bool StoreEverything=false; // activate if you want to store frames and all RooStats::ProfileLikelihoodCalculator *plc = new RooStats::ProfileLikelihoodCalculator(*data, *model); plc->SetParameters(*mu); plc->SetNullParameters(*nullParams); plc->SetTestSize(0.05); RooStats::LikelihoodInterval *interval = plc->GetInterval(); bool ComputationSuccessful=false; UpperLimit = interval->UpperLimit(*mu,ComputationSuccessful); signif = 0.0; // plc->GetHypoTest()->Significance(); // deactivated significance (to make algorithm faster) if(!ComputationSuccessful) { cout << "There seems to have been a problem. Returned upper limit is " << UpperLimit << " but it will be set to -999" << endl; UpperLimit=-999; signif=-999; } if(StoreEverything) { // Store it all RooRealVar* minv = (RooRealVar*)model->GetObservables()->first(); minv->setBins(static_cast<int>((minv->getMax()-minv->getMin())/5.)); RooPlot* frameEE = minv->frame(RooFit::Title("ee sample")); frameEE->GetXaxis()->CenterTitle(1); frameEE->GetYaxis()->CenterTitle(1); RooPlot* frameMM = minv->frame(RooFit::Title("mm sample")); frameMM->GetXaxis()->CenterTitle(1); frameMM->GetYaxis()->CenterTitle(1); RooPlot* frameOF = minv->frame(RooFit::Title("OF sample")); frameOF->GetXaxis()->CenterTitle(1); frameOF->GetYaxis()->CenterTitle(1); data->plotOn(frameMM,RooFit::Cut("catCentral==catCentral::MMCentral")); model->GetPdf()->plotOn(frameMM,RooFit::Slice(*ws->cat("catCentral"), "MMCentral"),RooFit::ProjWData(*data)); data->plotOn(frameEE,RooFit::Cut("catCentral==catCentral::EECentral")); model->GetPdf()->plotOn(frameEE,RooFit::Slice(*ws->cat("catCentral"), "EECentral"),RooFit::ProjWData(*data)); data->plotOn(frameOF,RooFit::Cut("catCentral==catCentral::OFOSCentral")); model->GetPdf()->plotOn(frameOF,RooFit::Slice(*ws->cat("catCentral"), "OFOSCentral"),RooFit::ProjWData(*data)); TFile *fout = new TFile("fout.root","UPDATE"); frameMM->Write(Concatenate(Concatenate(data->GetName(),"_MM"),tag),TObject::kOverwrite); frameEE->Write(Concatenate(Concatenate(data->GetName(),"_EE"),tag),TObject::kOverwrite); frameOF->Write(Concatenate(Concatenate(data->GetName(),"_OF"),tag),TObject::kOverwrite); fout->Close(); } delete plc; plc=0; }
void rf706_histpdf_modified_makeroohistpdf() { // gROOT->SetBatch(kTRUE); //load data TFile *inHistos= new TFile("output/histos.root", "READ"); TH1F * h100 = (TH1F*)inHistos->Get("cutmassLb7"); TFile * inHistos2 = new TFile("../lambda/output/histos.root", "READ"); TH1F * h200 = (TH1F*)inHistos2->Get("cutmassLb7"); double massLb = 5500; double massLbmin = 5300; double massLbmax = 5650; RooRealVar *mass = new RooRealVar("mass","m(#Lambda_{b})",massLb,"MeV"); RooDataHist *hist1 = new RooDataHist("hist1","1D",RooArgList(*mass),h100); RooDataHist *hist2 = new RooDataHist("hist2","1D",RooArgList(*mass),h200); // Represent data in hist1 as pdf in *mass RooHistPdf histpdf1 = makeroohistpdf(hist1,mass) ; // Plot binned data and histogram pdf overlaid RooPlot* frame1 = mass->frame(Title("#Sigma^{0} data with RooHistPdf")) ; frame1->SetMaximum(1100); hist1->plotOn(frame1) ; histpdf1.plotOn(frame1) ; histpdf1.paramOn(frame1) ; TCanvas* c1 = new TCanvas("rf706_histpdf","rf706_histpdf",800,400) ; c1->Divide(1,2); c1->cd(1); frame1->Draw() ; //see what happens if I try to fit histpdf1 to lambda data RooHistPdf histpdf2 = makeroohistpdf(hist1,mass); RooAbsReal * nll = histpdf2.createNLL(*hist2,Extended(kTRUE)); RooMinuit m(*nll); m.setVerbose(kTRUE); m.migrad(); m.minos(); RooPlot* frame2 = mass->frame(Title("#Lambda^{0} data fit with RooHistPdf from #Sigma^{0} data")); frame2->SetMaximum(1100); hist2->plotOn(frame2); histpdf2.plotOn(frame2); histpdf2.paramOn(frame2); c1->cd(2); frame2->Draw(); //save histpdf1 // cout<<"saving histpdf1..."<<endl; // histpdf1.RooHistPdf::SavePrimitive(std::cout); // gROOT->SetPrimitive(kFALSE); }
int main(){ RooMsgService::instance().setGlobalKillBelow(ERROR); TFile *bkgFile = TFile::Open("comb_svn/hgg.inputbkgdata_8TeV_MVA.root"); RooWorkspace *bkgWS = (RooWorkspace*)bkgFile->Get("cms_hgg_workspace"); RooRealVar *mass = (RooRealVar*)bkgWS->var("CMS_hgg_mass"); RooDataSet *data = (RooDataSet*)bkgWS->data("data_mass_cat0"); RooRealVar *p1 = new RooRealVar("p1","p1",-2.,-10.,0.); RooRealVar *p2 = new RooRealVar("p2","p2",-0.001,-0.01,0.01); RooRealVar *p3 = new RooRealVar("p3","p3",-0.0001,-0.01,0.01); //RooPowerLawSum *pow1 = new RooPowerLawSum("pow","pow",*mass,RooArgList(*p1)); //RooPowerLawSum *pow2 = new RooPowerLawSum("pow","pow",*mass,RooArgList(*p1,*p2)); //RooPowerLawSum *pow3 = new RooPowerLawSum("pow","pow",*mass,RooArgList(*p1,*p2,*p3)); RooExponentialSum *pow1 = new RooExponentialSum("pow1","pow1",*mass,RooArgList(*p1)); RooExponentialSum *pow2 = new RooExponentialSum("pow2","pow2",*mass,RooArgList(*p1,*p2)); RooExponentialSum *pow3 = new RooExponentialSum("pow3","pow3",*mass,RooArgList(*p1,*p2,*p3)); TCanvas *canv = new TCanvas(); RooPlot *frame = mass->frame(); data->plotOn(frame); cout << "bus" << endl; pow1->fitTo(*data,PrintEvalErrors(-1),PrintLevel(-1),Warnings(-1),Verbose(-1)); cout << "bus" << endl; pow1->plotOn(frame); pow2->fitTo(*data); pow2->plotOn(frame,LineColor(kRed),LineStyle(kDashed)); pow3->fitTo(*data); pow3->plotOn(frame,LineColor(kGreen),LineStyle(7)); frame->Draw(); canv->Print("test.pdf"); TFile *outFile = new TFile("test.root","RECREATE"); TTree *tree = new TTree("tree","tree"); vector<double> mu; mu.push_back(1.); mu.push_back(2.); mu.push_back(3.); mu.push_back(4.); vector<string> label; label.push_back("pol"); label.push_back("pow"); label.push_back("lau"); label.push_back("exp"); tree->Branch("mu",&mu); tree->Branch("label",&label); tree->Fill(); outFile->cd(); tree->Write(); outFile->Close(); return 0; }
void chi2(int xmin = 0, int xmax = 200, TString filename="../DsubMC/met2j0bIso2ewkScale_0_200.root", int nparam = 2){ RooAbsData::ErrorType errorType = RooAbsData::SumW2; file = new TFile(filename); RooRealVar* h = new RooRealVar("h","h",xmin,xmax); //Get Data TH1D* hData = file->Get("dataih"); hData->SetName("hData"); //hData->Draw(); RooDataHist* data = new RooDataHist("data","data",*h,hData); //Get Summed MC TH1D* hMC = file->Get("hh"); hMC->SetName("hMC"); hMC->Draw(); RooDataHist rdhMC("MC","MC",*h,hMC); RooHistPdf pdfMC("MCpdf","MCpdf",*h,rdhMC); //make (plot) the curves RooPlot* hFrame = h->frame(Name("hFrame")); data->plotOn(hFrame,RooFit::DataError(errorType)); pdfMC.plotOn(hFrame,ProjWData(*data),Components(pdfMC),Name("h_total")); //Determine Chi^2 double chi2fit = hFrame->chiSquare("h_total", "h_data", nparam); cout<<"Chi 2 / dof: "<<chi2fit<<endl; //Determine K-S double ks = hMC->KolmogorovTest(hData); cout<<"Kolmogorov-Smirnov: "<<ks<<endl; }
pair<double,double> bkgEvPerGeV(RooWorkspace *work, int m_hyp, int cat, int spin=false){ RooRealVar *mass = (RooRealVar*)work->var("CMS_hgg_mass"); if (spin) mass = (RooRealVar*)work->var("mass"); mass->setRange(100,180); RooAbsPdf *pdf = (RooAbsPdf*)work->pdf(Form("pdf_data_pol_model_8TeV_cat%d",cat)); RooAbsData *data = (RooDataSet*)work->data(Form("data_mass_cat%d",cat)); RooPlot *tempFrame = mass->frame(); data->plotOn(tempFrame,Binning(80)); pdf->plotOn(tempFrame); RooCurve *curve = (RooCurve*)tempFrame->getObject(tempFrame->numItems()-1); double nombkg = curve->Eval(double(m_hyp)); RooRealVar *nlim = new RooRealVar(Form("nlim%d",cat),"",0.,0.,1.e5); //double lowedge = tempFrame->GetXaxis()->GetBinLowEdge(FindBin(double(m_hyp))); //double upedge = tempFrame->GetXaxis()->GetBinUpEdge(FindBin(double(m_hyp))); //double center = tempFrame->GetXaxis()->GetBinUpCenter(FindBin(double(m_hyp))); nlim->setVal(nombkg); mass->setRange("errRange",m_hyp-0.5,m_hyp+0.5); RooAbsPdf *epdf = 0; epdf = new RooExtendPdf("epdf","",*pdf,*nlim,"errRange"); RooAbsReal *nll = epdf->createNLL(*data,Extended(),NumCPU(4)); RooMinimizer minim(*nll); minim.setStrategy(0); minim.setPrintLevel(-1); minim.migrad(); minim.minos(*nlim); double error = (nlim->getErrorLo(),nlim->getErrorHi())/2.; data->Print(); return pair<double,double>(nombkg,error); }
//#include "/uscms_data/d3/cvernier/DiH_13TeV/CMSSW_7_1_5/src/HiggsAnalysis/CombinedLimit/interface/RooMultiPdf.h" //#include "HiggsAnalysis/CombinedLimit/interface/RooMultiPdf.h" void makeRooMultiPdfWorkspace(){ // Load the combine Library gSystem->Load("libHiggsAnalysisCombinedLimit.so"); // Open the dummy H->gg workspace TFile *f_hgg = TFile::Open("w_background_Bern.root"); RooWorkspace *w_hgg = (RooWorkspace*)f_hgg->Get("HbbHbb"); // The observable (CMS_hgg_mass in the workspace) RooRealVar *mass = w_hgg->var("x"); // Get three of the functions inside, exponential, linear polynomial, power law RooAbsPdf *pdf_exp = w_hgg->pdf("bg_exp"); RooAbsPdf *pdf_pol = w_hgg->pdf("bg"); // Fit the functions to the data to set the "prefit" state (note this can and should be redone with combine when doing // bias studies as one typically throws toys from the "best-fit" RooAbsData *data = w_hgg->data("data_obs"); pdf_exp->fitTo(*data); // index 0 pdf_pol->fitTo(*data); // index 2 // Make a plot (data is a toy dataset) RooPlot *plot = mass->frame(); data->plotOn(plot); pdf_exp->plotOn(plot,RooFit::LineColor(kBlue)); pdf_pol->plotOn(plot,RooFit::LineColor(kRed)); plot->SetTitle("PDF fits to toy data"); plot->Draw(); // Make a RooCategory object. This will control which of the pdfs is "active" RooCategory cat("pdf_index","Index of Pdf which is active"); // Make a RooMultiPdf object. The order of the pdfs will be the order of their index, ie for below // 0 == exponential // 1 == linear function // 2 == powerlaw RooArgList mypdfs; mypdfs.add(*pdf_exp); mypdfs.add(*pdf_pol); RooMultiPdf multipdf("roomultipdf","All Pdfs",cat,mypdfs); // As usual make an extended term for the background with _norm for freely floating yield RooRealVar norm("roomultipdf_norm","Number of background events",0,10000); // Save to a new workspace TFile *fout = new TFile("background_pdfs.root","RECREATE"); RooWorkspace wout("backgrounds","backgrounds"); wout.import(cat); wout.import(norm); wout.import(multipdf); wout.Print(); wout.Write(); }
void FitterUtils::PlotShape1D(RooDataSet& originDataSet, RooDataSet& genDataSet, RooAbsPdf& shape, string plotsfile, string canvName, RooRealVar& B_plus_M) { TFile f2(plotsfile.c_str(), "UPDATE"); RooPlot* plotGen = B_plus_M.frame(Binning(20)); genDataSet.plotOn(plotGen); RooPlot* plotM = B_plus_M.frame(); originDataSet.plotOn(plotM); shape.plotOn(plotM); TCanvas canv(canvName.c_str(), canvName.c_str(), 800, 800); canv.Divide(1,2); canv.cd(1); plotGen->Draw(); canv.cd(2); plotM->Draw(); canv.Write(); f2.Close(); }
void FitterUtils::plot_fit_result(string plotsfile, RooAbsPdf &totPdf, RooDataSet dataGenTot) { //**************Prepare TFile to save the plots TFile f2(plotsfile.c_str(), "UPDATE"); //**************Plot the results of the fit RooArgSet *var_set = totPdf.getObservables(dataGenTot); TIterator *iter = var_set->createIterator(); RooRealVar *var; std::vector<RooPlot*> plots; RooPlot* frame; while((var = (RooRealVar*) iter->Next())) { frame = var->frame(); dataGenTot.plotOn(frame); totPdf.plotOn(frame, Components("histPdfPartReco"), LineColor(kBlue)); totPdf.plotOn(frame, Components("histPdfSignalZeroGamma"), LineColor(kGreen)); totPdf.plotOn(frame, Components("histPdfSignalOneGamma"), LineColor(kMagenta)); totPdf.plotOn(frame, Components("histPdfSignalTwoGamma"), LineColor(kOrange)); totPdf.plotOn(frame, Components("histPdfJpsiLeak"), LineColor(14)); totPdf.plotOn(frame, Components("combPDF"), LineColor(kBlack)); totPdf.plotOn(frame, LineColor(kRed)); plots.push_back(frame); } if (!(plots.size())) return; TCanvas cFit("cFit", "cFit", 600, 800); cFit.Divide(1,2); cFit.cd(1); plots[0]->Draw(); if (plots.size()>1){ cFit.cd(2); plots[1]->Draw(); } cFit.Write(); f2.Close(); }
void plotFromWorkspace() { TFile* file = new TFile("card_m125_1JetIncl_XX_workspace.root"); RooWorkspace* w = (RooWorkspace*)file->Get("w"); RooRealVar* m = (RooRealVar*)w->var("CMS_hmumu_mass"); RooRealVar* e = (RooRealVar*)w->var("CMS_hmumu_merr"); RooDataSet* d = (RooDataSet*)w->data("data_pseudo"); RooAbsPdf * b = w->pdf("bkg_mass_merr_1JetIncl_XX_pdf"); RooAbsPdf * s = w->pdf("sig_mass_merr_ggH_1JetIncl_XX_pdf"); RooPlot* frame = m->frame(); d->plotOn(frame); b->plotOn(frame); //s->plotOn(frame, RooFit::ProjWData(*e, *d), RooFit::LineColor(kOrange+1)); //s->plotOn(frame, RooFit::LineColor(kOrange+1)); frame->Draw(); }
void simul(){ TFile* in = new TFile( "../bin/Kdata.root", "READ" ); TH1D* h = in->Get("tof_8"); RooRealVar * x = new RooRealVar( "x", "x", -10, 10 ); RooDataHist * rdh = new RooDataHist( "data", "data", RooArgSet( *x ), h); RooRealVar m( "mean", "mean", 0, -1, 1 ); RooRealVar s( "sigma", "sigma", .5, 0, 1 ); RooGaussian g( "gauss", "gauss", ) RooPlot * frame = x->frame(); rdh->plotOn( frame ); frame->Draw(); }
void plot_with_residuals(TCanvas& _c,RooPlot& _frame,RooRealVar& var,Int_t& _nbins,Double_t& r_min,Double_t& r_max) { _c.SetName("_c"); _c.Divide(1,2); _c_1->SetPad(0.01,0.16,0.99,0.99); _c_2->SetPad(0.01,0.01,0.99,0.16); _c.cd(1); _frame.Draw(); _c.cd(2); RooHist* hpull = _frame.pullHist(); RooPlot* frame_pull = var.frame(Title(" "),Range(r_min,r_max),Bins(_nbins)); frame_pull->addPlotable(hpull,"P"); // this is if you want residuals in number of events /*RooHist* hresid = _frame -> residHist();*/ /*RooPlot* frame2 = m_Kpipi.frame(1000,2000,25);*/ /*frame2->addPlotable(hresid,"P");*/ frame_pull->SetMinimum(-5); frame_pull->SetMaximum(+5); frame_pull->SetNdivisions(0,"x"); // 510 for having also an x scale here frame_pull->SetNdivisions(203,"y"); // axis divisions was 510 frame_pull->SetXTitle(" "); frame_pull->SetLabelSize(0.15,"Y"); frame_pull->Draw(); TLine *_line = new TLine(r_min,-3.,r_max,-3); _line->SetLineStyle(1); _line->SetLineColor(2); _line->SetLineWidth(1); _line->Draw(); _line2 = new TLine(r_min,+3.,r_max,+3); _line2->SetLineStyle(1); _line2->SetLineColor(2); _line2->SetLineWidth(1); _line2->Draw(); }
void FitterUtilsSimultaneousExpOfPolyTimesX::plot_kemu_fit_result(string plotsfile, RooAbsPdf &totKemuPdf, RooDataSet const& dataGenKemu) { //**************Prepare TFile to save the plots TFile f2(plotsfile.c_str(), "UPDATE"); //**************Plot the results of the fit RooArgSet *var_set = totKemuPdf.getObservables(dataGenKemu); TIterator *iter = var_set->createIterator(); RooRealVar *var; std::vector<RooPlot*> plots; RooPlot* frame; while((var = (RooRealVar*) iter->Next())) { frame = var->frame(); dataGenKemu.plotOn(frame); totKemuPdf.plotOn(frame, LineColor(kRed)); plots.push_back(frame); } if (!(plots.size())) return; TCanvas cFit("cKemuFit", "cKemuFit", 600, 800); cFit.Divide(1,2); cFit.cd(1); plots[0]->Draw(); if (plots.size()>1){ cFit.cd(2); plots[1]->Draw(); } cFit.Write(); f2.Close(); }
void FitBias(TString CAT,TString CUT,float SIG,float BKG,int NTOYS) { gROOT->ForceStyle(); RooMsgService::instance().setSilentMode(kTRUE); RooMsgService::instance().setStreamStatus(0,kFALSE); RooMsgService::instance().setStreamStatus(1,kFALSE); // ----------------------------------------- TFile *fTemplates = TFile::Open("templates_"+CUT+"_"+CAT+"_workspace.root"); RooWorkspace *wTemplates = (RooWorkspace*)fTemplates->Get("w"); RooRealVar *x = (RooRealVar*)wTemplates->var("mTop"); RooAbsPdf *pdf_signal = (RooAbsPdf*)wTemplates->pdf("ttbar_pdf_Nominal"); RooAbsPdf *pdf_bkg = (RooAbsPdf*)wTemplates->pdf("qcdCor_pdf"); TRandom *rnd = new TRandom(); rnd->SetSeed(0); x->setBins(250); RooPlot *frame; TFile *outf; if (NTOYS > 1) { outf = TFile::Open("FitBiasToys_"+CUT+"_"+CAT+".root","RECREATE"); } float nSigInj,nBkgInj,nSigFit,nBkgFit,eSigFit,eBkgFit,nll; TTree *tr = new TTree("toys","toys"); tr->Branch("nSigInj",&nSigInj,"nSigInj/F"); tr->Branch("nSigFit",&nSigFit,"nSigFit/F"); tr->Branch("nBkgInj",&nBkgInj,"nBkgInj/F"); tr->Branch("nBkgFit",&nBkgFit,"nBkgFit/F"); tr->Branch("eSigFit",&eSigFit,"eSigFit/F"); tr->Branch("eBkgFit",&eBkgFit,"eBkgFit/F"); tr->Branch("nll" ,&nll ,"nll/F"); for(int itoy=0;itoy<NTOYS;itoy++) { // generate pseudodataset nSigInj = rnd->Poisson(SIG); nBkgInj = rnd->Poisson(BKG); RooRealVar *nSig = new RooRealVar("nSig","nSig",nSigInj); RooRealVar *nBkg = new RooRealVar("nBkg","nBkg",nBkgInj); RooAddPdf *model = new RooAddPdf("model","model",RooArgList(*pdf_signal,*pdf_bkg),RooArgList(*nSig,*nBkg)); RooDataSet *data = model->generate(*x,nSigInj+nBkgInj); RooDataHist *roohist = new RooDataHist("roohist","roohist",RooArgList(*x),*data); // build fit model RooRealVar *nFitSig = new RooRealVar("nFitSig","nFitSig",SIG,0,10*SIG); RooRealVar *nFitBkg = new RooRealVar("nFitBkg","nFitBkg",BKG,0,10*BKG); RooAddPdf *modelFit = new RooAddPdf("modelFit","modelFit",RooArgList(*pdf_signal,*pdf_bkg),RooArgList(*nFitSig,*nFitBkg)); // fit the pseudo dataset RooFitResult *res = modelFit->fitTo(*roohist,RooFit::Save(),RooFit::Extended(kTRUE)); //res->Print(); nSigFit = nFitSig->getVal(); nBkgFit = nFitBkg->getVal(); eSigFit = nFitSig->getError(); eBkgFit = nFitBkg->getError(); nll = res->minNll(); tr->Fill(); if (itoy % 100 == 0) { cout<<"Toy #"<<itoy<<": injected = "<<nSigInj<<", fitted = "<<nSigFit<<", error = "<<eSigFit<<endl; } if (NTOYS == 1) { frame = x->frame(); roohist->plotOn(frame); model->plotOn(frame); } } if (NTOYS == 1) { TCanvas *can = new TCanvas("Toy","Toy",900,600); frame->Draw(); } else { outf->cd(); tr->Write(); outf->Close(); fTemplates->Close(); } }
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 runUPWW() { int higgsMass=125; double intLumi=5.1; int nToys = 10; bool draw=true; using namespace RooFit; gROOT->ProcessLine(".L ~/tdrstyle.C"); setTDRStyle(); gStyle->SetPadLeftMargin(0.16); gROOT->ForceStyle(); gROOT->ProcessLine(".L statsFactory.cc+"); // // set up test kind // double sigRate; double bkgRate; if(higgsMass==125){ sigRate = 7.; bkgRate = 66.; }else{ cout << "HMMMM.... I don't know that mass point...BYE!" << endl; return; } RooRealVar* mll = new RooRealVar("mll","dilepton mass [GeV]", 12, 80.); mll->setBins(17); RooArgSet* obs = new RooArgSet(*mll) ; // read signal hypothesis 1 TChain *tsigHyp1 = new TChain("angles"); tsigHyp1->Add(Form("datafiles/bdtpresel/%i/SMHiggsWW_%i_JHU.root",higgsMass, higgsMass)); RooDataSet *sigHyp1Data = new RooDataSet("sigHyp1Data","sigHyp1Data",tsigHyp1,*obs); RooDataHist *sigHyp1Hist = sigHyp1Data->binnedClone(0); RooHistPdf* sigHyp1Pdf = new RooHistPdf("sigHyp1Pdf", "sigHyp1Pdf", *obs, *sigHyp1Hist); // read background TChain *bkgTree = new TChain("angles"); bkgTree->Add(Form("datafiles/bdtpresel/%i/WW_madgraph_8TeV.root",higgsMass)); RooDataSet *bkgData = new RooDataSet("bkgData","bkgData",bkgTree,*obs); RooDataHist *bkgHist = bkgData->binnedClone(0); RooHistPdf* bkgPdf = new RooHistPdf("bkgPdf", "bkgPdf", *obs, *bkgHist); char statResults[25]; statsFactory *hwwuls; sprintf(statResults,"uls_hww125_%.0ffb.root", intLumi); hwwuls = new statsFactory(obs, sigHyp1Pdf, sigHyp1Pdf, statResults); hwwuls->runUpperLimitWithBackground(sigRate*intLumi, bkgRate*intLumi, bkgPdf, nToys); delete hwwuls; // draw plots if(draw) { RooPlot* plot1 = mll->frame(); TString plot1Name = "mll"; TCanvas* c1 = new TCanvas("c1","c1",400,400); bkgData->plotOn(plot1,MarkerColor(kBlack)); bkgPdf->plotOn(plot1, LineColor(kBlack), LineStyle(kDashed)); sigHyp1Data->plotOn(plot1,MarkerColor(kRed)); sigHyp1Pdf->plotOn(plot1,LineColor(kRed), LineStyle(kDashed)); // draw... plot1->Draw(); c1->SaveAs(Form("plots/ul/epsfiles/%s.eps", plot1Name.Data())); c1->SaveAs(Form("plots/ul/pngfiles/%s.png", plot1Name.Data())); delete c1; } }
void MakePlots(RooWorkspace* ws){ // Here we make plots of the discriminating variable (invMass) after the fit // and of the control variable (isolation) after unfolding with sPlot. std::cout << "make plots" << std::endl; // make our canvas TCanvas* cdata = new TCanvas("sPlot","sPlot demo", 400, 600); cdata->Divide(1,3); // get what we need out of the workspace RooAbsPdf* model = ws->pdf("model"); RooAbsPdf* zModel = ws->pdf("zModel"); RooAbsPdf* qcdModel = ws->pdf("qcdModel"); RooRealVar* isolation = ws->var("isolation"); RooRealVar* invMass = ws->var("invMass"); // note, we get the dataset with sWeights RooDataSet* data = (RooDataSet*) ws->data("dataWithSWeights"); // this shouldn't be necessary, need to fix something with workspace // do this to set parameters back to their fitted values. model->fitTo(*data, Extended() ); //plot invMass for data with full model and individual componenets overlayed // TCanvas* cdata = new TCanvas(); cdata->cd(1); RooPlot* frame = invMass->frame() ; data->plotOn(frame ) ; model->plotOn(frame) ; model->plotOn(frame,Components(*zModel),LineStyle(kDashed), LineColor(kRed)) ; model->plotOn(frame,Components(*qcdModel),LineStyle(kDashed),LineColor(kGreen)) ; frame->SetTitle("Fit of model to discriminating variable"); frame->Draw() ; // Now use the sWeights to show isolation distribution for Z and QCD. // The SPlot class can make this easier, but here we demonstrait in more // detail how the sWeights are used. The SPlot class should make this // very easy and needs some more development. // Plot isolation for Z component. // Do this by plotting all events weighted by the sWeight for the Z component. // The SPlot class adds a new variable that has the name of the corresponding // yield + "_sw". cdata->cd(2); // create weightfed data set RooDataSet * dataw_z = new RooDataSet(data->GetName(),data->GetTitle(),data,*data->get(),0,"zYield_sw") ; RooPlot* frame2 = isolation->frame() ; dataw_z->plotOn(frame2, DataError(RooAbsData::SumW2) ) ; frame2->SetTitle("isolation distribution for Z"); frame2->Draw() ; // Plot isolation for QCD component. // Eg. plot all events weighted by the sWeight for the QCD component. // The SPlot class adds a new variable that has the name of the corresponding // yield + "_sw". cdata->cd(3); RooDataSet * dataw_qcd = new RooDataSet(data->GetName(),data->GetTitle(),data,*data->get(),0,"qcdYield_sw") ; RooPlot* frame3 = isolation->frame() ; dataw_qcd->plotOn(frame3,DataError(RooAbsData::SumW2) ) ; frame3->SetTitle("isolation distribution for QCD"); frame3->Draw() ; // cdata->SaveAs("SPlot.gif"); }
void draw_data_mgg(TString folderName,bool blind=true,float min=103,float max=160) { TFile inputFile(folderName+"/data.root"); const int nCat = 5; TString cats[5] = {"HighPt","Hbb","Zbb","HighRes","LowRes"}; TCanvas cv; for(int iCat=0; iCat < nCat; iCat++) { RooWorkspace *ws = (RooWorkspace*)inputFile.Get(cats[iCat]+"_mgg_workspace"); RooFitResult* res = (RooFitResult*)ws->obj("fitresult_pdf_data"); RooRealVar * mass = ws->var("mgg"); mass->setRange("all",min,max); mass->setRange("blind",121,130); mass->setRange("low",106,121); mass->setRange("high",130,160); mass->setUnit("GeV"); mass->SetTitle("m_{#gamma#gamma}"); RooAbsPdf * pdf = ws->pdf("pdf"); RooPlot *plot = mass->frame(min,max,max-min); plot->SetTitle(""); RooAbsData* data = ws->data("data")->reduce(Form("mgg > %f && mgg < %f",min,max)); double nTot = data->sumEntries(); if(blind) data = data->reduce("mgg < 121 || mgg>130"); double nBlind = data->sumEntries(); double norm = nTot/nBlind; //normalization for the plot data->plotOn(plot); pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::Range("Full"),RooFit::LineWidth(0.1) ); plot->Print(); //add the fix error band RooCurve* c = plot->getCurve("pdf_Norm[mgg]_Range[Full]_NormRange[Full]"); const int Nc = c->GetN(); //TGraphErrors errfix(Nc); //TGraphErrors errfix2(Nc); TGraphAsymmErrors errfix(Nc); TGraphAsymmErrors errfix2(Nc); Double_t *x = c->GetX(); Double_t *y = c->GetY(); double NtotalFit = ws->var("Nbkg1")->getVal()*ws->var("Nbkg1")->getVal() + ws->var("Nbkg2")->getVal()*ws->var("Nbkg2")->getVal(); for( int i = 0; i < Nc; i++ ) { errfix.SetPoint(i,x[i],y[i]); errfix2.SetPoint(i,x[i],y[i]); mass->setVal(x[i]); double shapeErr = pdf->getPropagatedError(*res)*NtotalFit; //double totalErr = TMath::Sqrt( shapeErr*shapeErr + y[i] ); //total normalization error double totalErr = TMath::Sqrt( shapeErr*shapeErr + y[i]*y[i]/NtotalFit ); if ( y[i] - totalErr > .0 ) { errfix.SetPointError(i, 0, 0, totalErr, totalErr ); } else { errfix.SetPointError(i, 0, 0, y[i] - 0.01, totalErr ); } //2sigma if ( y[i] - 2.*totalErr > .0 ) { errfix2.SetPointError(i, 0, 0, 2.*totalErr, 2.*totalErr ); } else { errfix2.SetPointError(i, 0, 0, y[i] - 0.01, 2.*totalErr ); } /* std::cout << x[i] << " " << y[i] << " " << " ,pdf get Val: " << pdf->getVal() << " ,pdf get Prop Err: " << pdf->getPropagatedError(*res)*NtotalFit << " stat uncertainty: " << TMath::Sqrt(y[i]) << " Ntot: " << NtotalFit << std::endl; */ } errfix.SetFillColor(kYellow); errfix2.SetFillColor(kGreen); //pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kGreen),RooFit::Range("Full"), RooFit::VisualizeError(*res,2.0,kFALSE)); //pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kYellow),RooFit::Range("Full"), RooFit::VisualizeError(*res,1.0,kFALSE)); //pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kGreen),RooFit::Range("Full"), RooFit::VisualizeError(*res,2.0,kTRUE)); //pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kYellow),RooFit::Range("Full"), RooFit::VisualizeError(*res,1.0,kTRUE)); plot->addObject(&errfix,"4"); plot->addObject(&errfix2,"4"); plot->addObject(&errfix,"4"); data->plotOn(plot); TBox blindBox(121,plot->GetMinimum()-(plot->GetMaximum()-plot->GetMinimum())*0.015,130,plot->GetMaximum()); blindBox.SetFillColor(kGray); if(blind) { plot->addObject(&blindBox); pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kGreen),RooFit::Range("Full"), RooFit::VisualizeError(*res,2.0,kTRUE)); pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kYellow),RooFit::Range("Full"), RooFit::VisualizeError(*res,1.0,kTRUE)); } //plot->addObject(&errfix,"4"); //data->plotOn(plot); //pdf->plotOn(plot,RooFit::Normalization( norm ) ); //pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::Range("Full"),RooFit::LineWidth(1.5) ); pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::Range("Full"), RooFit::LineWidth(1)); data->plotOn(plot); /* pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::Range("all"),RooFit::LineWidth(0.8) ); //pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::FillColor(kGreen),RooFit::Range("all"), RooFit::VisualizeError(*res,2.0,kFALSE)); //pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::FillColor(kYellow),RooFit::Range("all"), RooFit::VisualizeError(*res,1.0,kFALSE)); pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::FillColor(kGreen),RooFit::Range("all"), RooFit::VisualizeError(*res,2.0,kTRUE)); pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::FillColor(kYellow),RooFit::Range("all"), RooFit::VisualizeError(*res,1.0,kTRUE)); data->plotOn(plot); pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::Range("all"),RooFit::LineWidth(0.8) ); */ TLatex lbl0(0.1,0.96,"CMS Preliminary"); lbl0.SetNDC(); lbl0.SetTextSize(0.042); plot->addObject(&lbl0); TLatex lbl(0.4,0.96,Form("%s Box",cats[iCat].Data())); lbl.SetNDC(); lbl.SetTextSize(0.042); plot->addObject(&lbl); TLatex lbl2(0.6,0.96,"#sqrt{s}=8 TeV L = 19.78 fb^{-1}"); lbl2.SetNDC(); lbl2.SetTextSize(0.042); plot->addObject(&lbl2); int iObj=-1; TNamed *obj; while( (obj = (TNamed*)plot->getObject(++iObj)) ) { obj->SetName(Form("Object_%d",iObj)); } plot->Draw(); TString tag = (blind ? "_BLIND" : ""); cv.SaveAs(folderName+"/figs/mgg_data_"+cats[iCat]+tag+TString(Form("_%0.0f_%0.0f",min,max))+".png"); cv.SaveAs(folderName+"/figs/mgg_data_"+cats[iCat]+tag+TString(Form("_%0.0f_%0.0f",min,max))+".pdf"); cv.SaveAs(folderName+"/figs/mgg_data_"+cats[iCat]+tag+TString(Form("_%0.0f_%0.0f",min,max))+".C"); } }
// The actual job void backgroundFits_qqzz_1Dw(int channel, int sqrts, int VBFtag) { if(sqrts==7)return; TString schannel; if (channel == 1) schannel = "4mu"; else if (channel == 2) schannel = "4e"; else if (channel == 3) schannel = "2e2mu"; else cout << "Not a valid channel: " << schannel << endl; TString ssqrts = (long) sqrts + TString("TeV"); cout << "schannel = " << schannel << " sqrts = " << sqrts << " VBFtag = " << VBFtag << endl; TString outfile; if(VBFtag<2) outfile = "CardFragments/qqzzBackgroundFit_" + ssqrts + "_" + schannel + "_" + Form("%d",int(VBFtag)) + ".txt"; if(VBFtag==2) outfile = "CardFragments/qqzzBackgroundFit_" + ssqrts + "_" + schannel + ".txt"; ofstream of(outfile,ios_base::out); of << "### background functions ###" << endl; gSystem->AddIncludePath("-I$ROOFITSYS/include"); gROOT->ProcessLine(".L ../CreateDatacards/include/tdrstyle.cc"); setTDRStyle(false); gStyle->SetPadLeftMargin(0.16); TString filepath; if (sqrts==7) { filepath = filePath7TeV; } else if (sqrts==8) { filepath = filePath8TeV; } TChain* tree = new TChain("SelectedTree"); tree->Add( filepath+ "/" + (schannel=="2e2mu"?"2mu2e":schannel) + "/HZZ4lTree_ZZTo*.root"); RooRealVar* MC_weight = new RooRealVar("MC_weight","MC_weight",0.,2.) ; RooRealVar* ZZMass = new RooRealVar("ZZMass","ZZMass",100.,1000.); RooRealVar* NJets30 = new RooRealVar("NJets30","NJets30",0.,100.); RooArgSet ntupleVarSet(*ZZMass,*NJets30,*MC_weight); RooDataSet *set = new RooDataSet("set","set",ntupleVarSet,WeightVar("MC_weight")); Float_t myMC,myMass; Short_t myNJets; int nentries = tree->GetEntries(); tree->SetBranchAddress("ZZMass",&myMass); tree->SetBranchAddress("MC_weight",&myMC); tree->SetBranchAddress("NJets30",&myNJets); for(int i =0;i<nentries;i++) { tree->GetEntry(i); if(VBFtag==1 && myNJets<2)continue; if(VBFtag==0 && myNJets>1)continue; ntupleVarSet.setRealValue("ZZMass",myMass); ntupleVarSet.setRealValue("MC_weight",myMC); ntupleVarSet.setRealValue("NJets30",(double)myNJets); set->add(ntupleVarSet, myMC); } double totalweight = 0.; double totalweight_z = 0.; for (int i=0 ; i<set->numEntries() ; i++) { //set->get(i) ; RooArgSet* row = set->get(i) ; //row->Print("v"); totalweight += set->weight(); if (row->getRealValue("ZZMass") < 200) totalweight_z += set->weight(); } cout << "nEntries: " << set->numEntries() << ", totalweight: " << totalweight << ", totalweight_z: " << totalweight_z << endl; gSystem->Load("libHiggsAnalysisCombinedLimit.so"); //// --------------------------------------- //Background RooRealVar CMS_qqzzbkg_a0("CMS_qqzzbkg_a0","CMS_qqzzbkg_a0",115.3,0.,200.); RooRealVar CMS_qqzzbkg_a1("CMS_qqzzbkg_a1","CMS_qqzzbkg_a1",21.96,0.,200.); RooRealVar CMS_qqzzbkg_a2("CMS_qqzzbkg_a2","CMS_qqzzbkg_a2",122.8,0.,200.); RooRealVar CMS_qqzzbkg_a3("CMS_qqzzbkg_a3","CMS_qqzzbkg_a3",0.03479,0.,1.); RooRealVar CMS_qqzzbkg_a4("CMS_qqzzbkg_a4","CMS_qqzzbkg_a4",185.5,0.,200.); RooRealVar CMS_qqzzbkg_a5("CMS_qqzzbkg_a5","CMS_qqzzbkg_a5",12.67,0.,200.); RooRealVar CMS_qqzzbkg_a6("CMS_qqzzbkg_a6","CMS_qqzzbkg_a6",34.81,0.,100.); RooRealVar CMS_qqzzbkg_a7("CMS_qqzzbkg_a7","CMS_qqzzbkg_a7",0.1393,0.,1.); RooRealVar CMS_qqzzbkg_a8("CMS_qqzzbkg_a8","CMS_qqzzbkg_a8",66.,0.,200.); RooRealVar CMS_qqzzbkg_a9("CMS_qqzzbkg_a9","CMS_qqzzbkg_a9",0.07191,0.,1.); RooRealVar CMS_qqzzbkg_a10("CMS_qqzzbkg_a10","CMS_qqzzbkg_a10",94.11,0.,200.); RooRealVar CMS_qqzzbkg_a11("CMS_qqzzbkg_a11","CMS_qqzzbkg_a11",-5.111,-100.,100.); RooRealVar CMS_qqzzbkg_a12("CMS_qqzzbkg_a12","CMS_qqzzbkg_a12",4834,0.,10000.); RooRealVar CMS_qqzzbkg_a13("CMS_qqzzbkg_a13","CMS_qqzzbkg_a13",0.2543,0.,1.); if (channel == 1){ ///* 4mu CMS_qqzzbkg_a0.setVal(103.854); CMS_qqzzbkg_a1.setVal(10.0718); CMS_qqzzbkg_a2.setVal(117.551); CMS_qqzzbkg_a3.setVal(0.0450287); CMS_qqzzbkg_a4.setVal(185.262); CMS_qqzzbkg_a5.setVal(7.99428); CMS_qqzzbkg_a6.setVal(39.7813); CMS_qqzzbkg_a7.setVal(0.0986891); CMS_qqzzbkg_a8.setVal(49.1325); CMS_qqzzbkg_a9.setVal(0.0389984); CMS_qqzzbkg_a10.setVal(98.6645); CMS_qqzzbkg_a11.setVal(-7.02043); CMS_qqzzbkg_a12.setVal(5694.66); CMS_qqzzbkg_a13.setVal(0.0774525); //*/ } else if (channel == 2){ ///* 4e CMS_qqzzbkg_a0.setVal(111.165); CMS_qqzzbkg_a1.setVal(19.8178); CMS_qqzzbkg_a2.setVal(120.89); CMS_qqzzbkg_a3.setVal(0.0546639); CMS_qqzzbkg_a4.setVal(184.878); CMS_qqzzbkg_a5.setVal(11.7041); CMS_qqzzbkg_a6.setVal(33.2659); CMS_qqzzbkg_a7.setVal(0.140858); CMS_qqzzbkg_a8.setVal(56.1226); CMS_qqzzbkg_a9.setVal(0.0957699); CMS_qqzzbkg_a10.setVal(98.3662); CMS_qqzzbkg_a11.setVal(-6.98701); CMS_qqzzbkg_a12.setVal(10.0536); CMS_qqzzbkg_a13.setVal(0.110576); //*/ } else if (channel == 3){ ///* 2e2mu CMS_qqzzbkg_a0.setVal(110.293); CMS_qqzzbkg_a1.setVal(11.8334); CMS_qqzzbkg_a2.setVal(116.91); CMS_qqzzbkg_a3.setVal(0.0433151); CMS_qqzzbkg_a4.setVal(185.817); CMS_qqzzbkg_a5.setVal(10.5945); CMS_qqzzbkg_a6.setVal(29.6208); CMS_qqzzbkg_a7.setVal(0.0826); CMS_qqzzbkg_a8.setVal(53.1346); CMS_qqzzbkg_a9.setVal(0.0882081); CMS_qqzzbkg_a10.setVal(85.3776); CMS_qqzzbkg_a11.setVal(-13.3836); CMS_qqzzbkg_a12.setVal(7587.95); CMS_qqzzbkg_a13.setVal(0.325621); //*/ } else { cout << "disaster" << endl; } RooqqZZPdf_v2* bkg_qqzz = new RooqqZZPdf_v2("bkg_qqzz","bkg_qqzz",*ZZMass, CMS_qqzzbkg_a0,CMS_qqzzbkg_a1,CMS_qqzzbkg_a2,CMS_qqzzbkg_a3,CMS_qqzzbkg_a4, CMS_qqzzbkg_a5,CMS_qqzzbkg_a6,CMS_qqzzbkg_a7,CMS_qqzzbkg_a8, CMS_qqzzbkg_a9,CMS_qqzzbkg_a10,CMS_qqzzbkg_a11,CMS_qqzzbkg_a12,CMS_qqzzbkg_a13); RooArgSet myASet(*ZZMass, CMS_qqzzbkg_a0,CMS_qqzzbkg_a1,CMS_qqzzbkg_a2,CMS_qqzzbkg_a3,CMS_qqzzbkg_a4, CMS_qqzzbkg_a5,CMS_qqzzbkg_a6,CMS_qqzzbkg_a7); myASet.add(CMS_qqzzbkg_a8); myASet.add(CMS_qqzzbkg_a9); myASet.add(CMS_qqzzbkg_a10); myASet.add(CMS_qqzzbkg_a11); myASet.add(CMS_qqzzbkg_a12); myASet.add(CMS_qqzzbkg_a13); RooFitResult *r1 = bkg_qqzz->fitTo( *set, Save(kTRUE), SumW2Error(kTRUE) );//, Save(kTRUE), SumW2Error(kTRUE)) ; cout << endl; cout << "------- Parameters for " << schannel << " sqrts=" << sqrts << endl; cout << " a0_bkgd = " << CMS_qqzzbkg_a0.getVal() << endl; cout << " a1_bkgd = " << CMS_qqzzbkg_a1.getVal() << endl; cout << " a2_bkgd = " << CMS_qqzzbkg_a2.getVal() << endl; cout << " a3_bkgd = " << CMS_qqzzbkg_a3.getVal() << endl; cout << " a4_bkgd = " << CMS_qqzzbkg_a4.getVal() << endl; cout << " a5_bkgd = " << CMS_qqzzbkg_a5.getVal() << endl; cout << " a6_bkgd = " << CMS_qqzzbkg_a6.getVal() << endl; cout << " a7_bkgd = " << CMS_qqzzbkg_a7.getVal() << endl; cout << " a8_bkgd = " << CMS_qqzzbkg_a8.getVal() << endl; cout << " a9_bkgd = " << CMS_qqzzbkg_a9.getVal() << endl; cout << " a10_bkgd = " << CMS_qqzzbkg_a10.getVal() << endl; cout << " a11_bkgd = " << CMS_qqzzbkg_a11.getVal() << endl; cout << " a12_bkgd = " << CMS_qqzzbkg_a12.getVal() << endl; cout << " a13_bkgd = " << CMS_qqzzbkg_a13.getVal() << endl; cout << "}" << endl; cout << "---------------------------" << endl; of << "qqZZshape a0_bkgd " << CMS_qqzzbkg_a0.getVal() << endl; of << "qqZZshape a1_bkgd " << CMS_qqzzbkg_a1.getVal() << endl; of << "qqZZshape a2_bkgd " << CMS_qqzzbkg_a2.getVal() << endl; of << "qqZZshape a3_bkgd " << CMS_qqzzbkg_a3.getVal() << endl; of << "qqZZshape a4_bkgd " << CMS_qqzzbkg_a4.getVal() << endl; of << "qqZZshape a5_bkgd " << CMS_qqzzbkg_a5.getVal() << endl; of << "qqZZshape a6_bkgd " << CMS_qqzzbkg_a6.getVal() << endl; of << "qqZZshape a7_bkgd " << CMS_qqzzbkg_a7.getVal() << endl; of << "qqZZshape a8_bkgd " << CMS_qqzzbkg_a8.getVal() << endl; of << "qqZZshape a9_bkgd " << CMS_qqzzbkg_a9.getVal() << endl; of << "qqZZshape a10_bkgd " << CMS_qqzzbkg_a10.getVal() << endl; of << "qqZZshape a11_bkgd " << CMS_qqzzbkg_a11.getVal() << endl; of << "qqZZshape a12_bkgd " << CMS_qqzzbkg_a12.getVal() << endl; of << "qqZZshape a13_bkgd " << CMS_qqzzbkg_a13.getVal() << endl; of << endl << endl; of.close(); cout << endl << "Output written to: " << outfile << endl; double qqzznorm; if (channel == 1) qqzznorm = 20.5836; else if (channel == 2) qqzznorm = 13.8871; else if (channel == 3) qqzznorm = 32.9883; else { cout << "disaster!" << endl; } ZZMass->setRange("fullrange",100.,1000.); ZZMass->setRange("largerange",100.,600.); ZZMass->setRange("zoomrange",100.,200.); double rescale = qqzznorm/totalweight; double rescale_z = qqzznorm/totalweight_z; cout << "rescale: " << rescale << ", rescale_z: " << rescale_z << endl; // Plot m4l and RooPlot* frameM4l = ZZMass->frame(Title("M4L"),Range(100,600),Bins(250)) ; set->plotOn(frameM4l, MarkerStyle(20), Rescale(rescale)) ; //set->plotOn(frameM4l) ; RooPlot* frameM4lz = ZZMass->frame(Title("M4L"),Range(100,200),Bins(100)) ; set->plotOn(frameM4lz, MarkerStyle(20), Rescale(rescale)) ; int iLineColor = 1; string lab = "blah"; if (channel == 1) { iLineColor = 2; lab = "4#mu"; } if (channel == 3) { iLineColor = 4; lab = "2e2#mu"; } if (channel == 2) { iLineColor = 6; lab = "4e"; } bkg_qqzz->plotOn(frameM4l,LineColor(iLineColor),NormRange("largerange")) ; bkg_qqzz->plotOn(frameM4lz,LineColor(iLineColor),NormRange("zoomrange")) ; //second shape to compare with (if previous comparison code unceommented) //bkg_qqzz_bkgd->plotOn(frameM4l,LineColor(1),NormRange("largerange")) ; //bkg_qqzz_bkgd->plotOn(frameM4lz,LineColor(1),NormRange("zoomrange")) ; double normalizationBackground_qqzz = bkg_qqzz->createIntegral( RooArgSet(*ZZMass), Range("fullrange") )->getVal(); cout << "Norm all = " << normalizationBackground_qqzz << endl; frameM4l->GetXaxis()->SetTitle("m_{4l} [GeV]"); frameM4l->GetYaxis()->SetTitle("a.u."); frameM4lz->GetXaxis()->SetTitle("m_{4l} [GeV]"); frameM4lz->GetYaxis()->SetTitle("a.u."); char lname[192]; sprintf(lname,"qq #rightarrow ZZ #rightarrow %s", lab.c_str() ); char lname2[192]; sprintf(lname2,"Shape Model, %s", lab.c_str() ); // dummy! TF1* dummyF = new TF1("dummyF","1",0.,1.); TH1F* dummyH = new TH1F("dummyH","",1, 0.,1.); dummyF->SetLineColor( iLineColor ); dummyF->SetLineWidth( 2 ); dummyH->SetLineColor( kBlue ); TLegend * box2 = new TLegend(0.4,0.70,0.80,0.90); box2->SetFillColor(0); box2->SetBorderSize(0); box2->AddEntry(dummyH,"Simulation (POWHEG+Pythia) ","pe"); box2->AddEntry(dummyH,lname,""); box2->AddEntry(dummyH,"",""); box2->AddEntry(dummyF,lname2,"l"); TPaveText *pt = new TPaveText(0.15,0.955,0.4,0.99,"NDC"); pt->SetFillColor(0); pt->SetBorderSize(0); pt->AddText("CMS Preliminary 2012"); TPaveText *pt2 = new TPaveText(0.84,0.955,0.99,0.99,"NDC"); pt2->SetFillColor(0); pt2->SetBorderSize(0); TString entag;entag.Form("#sqrt{s} = %d TeV",sqrts); pt2->AddText(entag.Data()); TCanvas *c = new TCanvas("c","c",800,600); c->cd(); frameM4l->Draw(); frameM4l->GetYaxis()->SetRangeUser(0,0.4); if(channel == 3)frameM4l->GetYaxis()->SetRangeUser(0,0.7); box2->Draw(); pt->Draw(); pt2->Draw(); TString outputPath = "bkgFigs"; outputPath = outputPath+ (long) sqrts + "TeV/"; TString outputName; if(VBFtag<2) outputName = outputPath + "bkgqqzz_" + schannel + "_" + Form("%d",int(VBFtag)); if(VBFtag==2) outputName = outputPath + "bkgqqzz_" + schannel; c->SaveAs(outputName + ".eps"); c->SaveAs(outputName + ".png"); TCanvas *c2 = new TCanvas("c2","c2",1000,500); c2->Divide(2,1); c2->cd(1); frameM4l->Draw(); box2->Draw("same"); c2->cd(2); frameM4lz->Draw(); box2->Draw("same"); if (VBFtag<2) outputName = outputPath + "bkgqqzz_" + schannel + "_z" + "_" + Form("%d",int(VBFtag)); if (VBFtag==2) outputName = outputPath + "bkgqqzz_" + schannel + "_z"; c2->SaveAs(outputName + ".eps"); c2->SaveAs(outputName + ".png"); /* TO make the ratio btw 2 shapes, if needed for compairson TCanvas *c3 = new TCanvas("c3","c3",1000,500); if(sqrts==7) sprintf(outputName, "bkgFigs7TeV/bkgqqzz_%s_ratio.eps",schannel.c_str()); else if(sqrts==8) sprintf(outputName, "bkgFigs8TeV/bkgqqzz_%s_ratio.eps",schannel.c_str()); const int nPoints = 501.; double masses[nPoints] ; int j=0; for (int i=100; i<601; i++){ masses[j] = i; j++; } cout<<j<<endl; double effDiff[nPoints]; for (int i = 0; i < nPoints; i++){ ZZMass->setVal(masses[i]); double eval = (bkg_qqzz_bkgd->getVal(otherASet)-bkg_qqzz->getVal(myASet))/(bkg_qqzz->getVal(myASet)); //cout<<bkg_qqzz_bkgd->getVal(otherASet)<<" "<<bkg_qqzz->getVal(myASet)<<" "<<eval<<endl; effDiff[i]=eval; } TGraph* grEffDiff = new TGraph( nPoints, masses, effDiff ); grEffDiff->SetMarkerStyle(20); grEffDiff->Draw("AL"); //c3->SaveAs(outputName); */ if (VBFtag<2) outputName = outputPath + "bkgqqzz_" + schannel + "_z" + "_" + Form("%d",int(VBFtag)) + ".root"; if (VBFtag==2) outputName = outputPath + "bkgqqzz_" + schannel + "_z" + ".root"; TFile* outF = new TFile(outputName,"RECREATE"); outF->cd(); c2->Write(); frameM4l->Write(); frameM4lz->Write(); outF->Close(); delete c; delete c2; }
//Either with fractions: //RooRealVar fracJpsi("fracJpsi","The Jpsi signal fraction",0.6,0.,1.); //RooAddPdf totSigPDF("totSigPDF","The total Signal PDF",RooArgList(gaussJpsi,gausspsi),RooArgList(fracJpsi)); //RooRealVar fracSig("fracSig","The signal fraction",0.2,0.,1.); //RooAddPdf totPDF("totPDF","The total PDF",RooArgList(totSigPDF,backPDF),RooArgList(fracSig)); //Or extended RooRealVar NJpsi("NJpsi","The Jpsi signal events",9000.,0.1,20000.); RooRealVar Npsi("Npsi","The psi signal events",300.,0.1,600.); RooRealVar Nbkg("Nbkg","The bkg events",20000.,0.1,50000.); RooAddPdf totPDF("totPDF","The total PDF",RooArgList(CBJpsi,gausspsi,backPDF),RooArgList(NJpsi,Npsi,Nbkg)); totPDF.fitTo(*data,RooFit::Extended(1)); RooPlot *xframe = mass.frame(); data->plotOn(xframe); //totPDF.plotOn(xframe); TCanvas c1; c1.cd(); xframe->Draw(); c1.SaveAs("exercise_final.gif"); RooWorkspace w("w"); w.import(*data); w.import(totPDF); TFile fOut("Workspace_final.root","RECREATE"); fOut.cd(); w.Write();
void fit_mass(TString fileN="") {//suffix added before file extension, e.g., '.pdf' TString placeholder;//to add strings before using them, e.g., for saving text files gROOT->SetBatch(kTRUE); gROOT->ProcessLine(".x /afs/cern.ch/user/m/mwilkins/cmtuser/src/lhcbStyle.C"); // gStyle->SetPadTickX(1); // gStyle->SetPadTickY(1); // gStyle->SetPadLeftMargin(0.15); // gStyle->SetTextSize(0.3); // //open file and get histogram // TFile *inHistos = new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/data/histos_data.root", "READ"); // TH1F * h100 = (TH1F*)inHistos->Get("h70"); // cout<<"data histogram gotten"<<endl; //unbinned TFile *hastree = new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/data/cutfile_Optimized.root", "READ"); TTree * h100 = (TTree*)hastree->Get("mytree"); cout<<"tree gotten"<<endl; TFile *SMChistos= new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/MC/withKScut/histos_SMCfile_fullMC.root", "READ"); cout<<"SMC file opened"<<endl; TH1F *SMCh = (TH1F*)SMChistos->Get("h00"); cout<<"SMC hist gotten"<<endl; RooRealVar *mass = new RooRealVar("Bs_LOKI_MASS_JpsiConstr","m(J/#psi #Lambda)",4100,6100,"MeV"); mass->setRange("bkg1",4300,4800); mass->setRange("bkg2",5700,5950); mass->setRange("bkg3",4300,5500); mass->setRange("bkg4",5100,5500); mass->setRange("L",5350,5950); mass->setRange("tot",4300,5950); cout<<"mass declared"<<endl; // RooDataHist *data = new RooDataHist("data","1D",RooArgList(*mass),h100); //unbinned RooDataSet *data = new RooDataSet("data","1D",h100,*mass); cout<<"data declared"<<endl; RooDataHist *SMC = new RooDataHist("SMC","1D",RooArgList(*mass),SMCh); cout<<"SMC hist assigned to RooDataHist"<<endl; // Construct Pdf Model // /\0 //gaussian RooRealVar mean1L("mean1L","/\\ gaus 1: mean",5621.103095,5525,5700); RooRealVar sig1L("sig1L","/\\ gaus 1: sigma",6.898126,0,100); RooGaussian gau1L("gau1L","#Lambda signal: gaussian 1",*mass,mean1L,sig1L); RooFormulaVar mean2L("mean2L","@0",mean1L); RooRealVar sig2L("sig2L","/\\ gaus 2: sigma",14.693117,0,100); RooGaussian gau2L("gau2L","#Lambda signal: gaussian 2",*mass,mean2L,sig2L); RooRealVar f1L("f1L","/\\ signal: fraction gaussian 1",0.748776,0,1); RooAddPdf sigL("sigL","#Lambda signal",RooArgList(gau1L,gau2L),RooArgList(f1L)); // //CB // RooRealVar mean3L("mean3L","/\\ CB: mean",5621.001,5525,5700); // RooRealVar sig3L("sig3L","/\\ CB: sigma",5.161,0,100); // RooRealVar alphaL3("alphaL3","/\\ CB: alpha",2.077,0,1000); // RooRealVar nL3("nL1","/\\ CB: n",0.286,0,1000); // RooCBShape CBL("CBL","#Lambda signal: CB",*mass,mean3L,sig3L,alphaL3,nL3); // RooRealVar mean4L("mean4L","/\\ gaus: mean",5621.804,5525,5700); // RooRealVar sig4L("sig4L","/\\ gaus: sigma",10.819,0,100); // RooGaussian gauL("gauL","#Lambda signal: gaussian",*mass,mean4L,sig4L); // RooRealVar f1L("f1L","/\\ signal: fraction CB",0.578,0,1); // RooAddPdf sigL("sigL","#Lambda signal",RooArgList(CBL,gauL),RooArgList(f1L)); // sigma0 //using RooHistPdf from MC--no need to build pdf here RooHistPdf sigS = makeroohistpdf(SMC,mass,"sigS","#Sigma^{0} signal (RooHistPdf)"); // /\* cout<<"Lst stuff"<<endl; RooRealVar meanLst1("meanLst1","/\\*(misc.): mean1",5011.031237,4900,5100); RooRealVar sigLst1("sigLst1","/\\*(misc.): sigma1",70.522092,0,100); RooRealVar meanLst2("mean5Lst2","/\\*(1405): mean2",5245.261703,5100,5350); RooRealVar sigLst2("sigLst2","/\\*(1405): sigma2",64.564763,0,100); RooRealVar alphaLst2("alphaLst2","/\\*(1405): alpha2",29.150301); RooRealVar nLst2("nLst2","/\\*(1405): n2",4.615817,0,50); RooGaussian gauLst1("gauLst1","#Lambda*(misc.), gaus",*mass,meanLst1,sigLst1); RooCBShape gauLst2("gauLst2","#Lambda*(1405), CB",*mass,meanLst2,sigLst2,alphaLst2,nLst2); // RooRealVar fLst1("fLst1","/\\* bkg: fraction gaus 1",0.743,0,1); // RooAddPdf bkgLst("bkgLst","#Lambda* signal",RooArgList(gauLst1,gauLst2),RooArgList(fLst1)); //Poly func BKG mass // RooRealVar b0("b0","Background: Chebychev b0",-1.071,-10000,10000); RooRealVar b1("b1","Background: Chebychev b1",-1.323004,-10,-0.00000000000000000000001); RooRealVar b2("b2","Background: Chebychev b2",0.145494,0,10); RooRealVar b3("b3","Background: Chebychev b3",-0.316,-10000,10000); RooRealVar b4("b4","Background: Chebychev b4",0.102,-10000,10000); RooRealVar b5("b5","Background: Chebychev b5",0.014,-10000,10000); RooRealVar b6("b6","Background: Chebychev b6",-0.015,-10000,10000); RooRealVar b7("b7","Background: Chebychev b7",0.012,-10000,10000); RooArgList bList(b1,b2); RooChebychev bkg("bkg","Background", *mass, bList); // TF1 *ep = new TF1("ep","[2]*exp([0]*x+[1]*x*x)",4300,5950); // ep->SetParameter(0,1); // ep->SetParameter(1,-1); // ep->SetParameter(2,2000); // ep->SetParName(0,"a"); // ep->SetParName(1,"b"); // ep->SetParName(2,"c"); // RooRealVar a("a","Background: Coefficent of x",1,-10000,10000); // RooRealVar b("b","Background: Coefficent of x*x",-1,-10000,10000); // RooRealVar c("c","Background: Coefficent of exp()",2000,-10000,10000); // RooTFnPdfBinding bkg("ep","ep",ep,RooArgList(*mass,a,b)); //number of each shape RooRealVar nbkg("nbkg","N bkg",2165.490249,0,100000000); RooRealVar nsigL("nsigL","N /\\",1689.637290,0,1000000000); RooRealVar nsigS("nsigS","N sigma",0.000002,0,10000000000); RooRealVar ngauLst1("ngauLst1","N /\\*(misc.)",439.812103,0,10000000000); RooRealVar ngauLst2("ngauLst2","N /\\*(1405)",152.061617,0,10000000000); RooRealVar nbkgLst("nbkgLst","N /\\*",591.828,0,1000000000); //add shapes and their number to a totalPdf RooArgList shapes; RooArgList yields; shapes.add(sigL); yields.add(nsigL); shapes.add(sigS); yields.add(nsigS); // shapes.add(bkgLst); yields.add(nbkgLst); shapes.add(gauLst1); yields.add(ngauLst1); shapes.add(gauLst2); yields.add(ngauLst2); shapes.add(bkg); yields.add(nbkg); RooAddPdf totalPdf("totalPdf","totalPdf",shapes,yields); //fit the totalPdf RooAbsReal * nll = totalPdf.createNLL(*data,Extended(kTRUE),Range("tot")); RooMinuit m(*nll); m.setVerbose(kFALSE); m.migrad(); m.minos(); m.minos(); //display and save information ofstream textfile;//create text file to hold data placeholder = "plots/fit"+fileN+".txt"; textfile.open(placeholder); TString outputtext;//for useful text //plot things RooPlot *framex = mass->frame(); framex->GetYaxis()->SetTitle("Events/(5 MeV)"); data->plotOn(framex,Name("Hist"),MarkerColor(kBlack),LineColor(kBlack),DataError(RooAbsData::SumW2)); totalPdf.plotOn(framex,Name("curvetot"),LineColor(kBlue)); RooArgSet* totalPdfComponents = totalPdf.getComponents(); TIterator* itertPC = totalPdfComponents->createIterator(); RooAddPdf* vartPC = (RooAddPdf*) itertPC->Next(); vartPC = (RooAddPdf*) itertPC->Next();//skip totalPdf int i=0;//color index TLegend *leg = new TLegend(0.2, 0.02, .4, .42); leg->SetTextSize(0.06); leg->AddEntry(framex->findObject("curvetot"),"Total PDF","l"); while(vartPC){//loop over compotents of totalPdf TString vartPCtitle = vartPC->GetTitle(); TIterator* itercompPars;//forward declare so it persists outside the if statement RooRealVar* varcompPars; if(!(vartPCtitle.Contains(":")||vartPCtitle.Contains("@"))){//only for non-sub-shapes while(i==0||i==10||i==4||i==1||i==5||(i>=10&&i<=27))i++;//avoid white and blue and black and yellow and horribleness RooArgSet* compPars = vartPC->getParameters(data);//set of the parameters of the component the loop is on itercompPars = compPars->createIterator(); varcompPars = (RooRealVar*) itercompPars->Next(); while(varcompPars){//write and print mean, sig, etc. of sub-shapes TString vartitle = varcompPars->GetTitle(); double varval = varcompPars->getVal(); TString varvalstring = Form("%f",varval); double hi = varcompPars->getErrorHi(); TString varerrorstring = "[exact]"; if(hi!=-1){ double lo = varcompPars->getErrorLo(); double varerror = TMath::Max(fabs(lo),hi); varerrorstring = Form("%E",varerror); } outputtext = vartitle+" = "+varvalstring+" +/- "+varerrorstring; textfile<<outputtext<<endl; cout<<outputtext<<endl; varcompPars = (RooRealVar*) itercompPars->Next(); } totalPdf.plotOn(framex,Name(vartPC->GetName()),LineStyle(kDashed),LineColor(i),Components(vartPC->GetName())); leg->AddEntry(framex->findObject(vartPC->GetName()),vartPCtitle,"l"); i++; } vartPC = (RooAddPdf*) itertPC->Next(); itercompPars->Reset();//make sure it's ready for the next vartPC } // Calculate chi2/ndf RooArgSet *floatpar = totalPdf.getParameters(data); int floatpars = (floatpar->selectByAttrib("Constant",kFALSE))->getSize(); Double_t chi2 = framex->chiSquare("curvetot","Hist",floatpars); TString chi2string = Form("%f",chi2); //create text box to list important parameters on the plot // TPaveText* txt = new TPaveText(0.1,0.5,0.7,0.9,"NBNDC"); // txt->SetTextSize(0.06); // txt->SetTextColor(kBlack); // txt->SetBorderSize(0); // txt->SetFillColor(0); // txt->SetFillStyle(0); outputtext = "#chi^{2}/N_{DoF} = "+chi2string; cout<<outputtext<<endl; textfile<<outputtext<<endl; // txt->AddText(outputtext); // Print stuff TIterator* iteryields = yields.createIterator(); RooRealVar* varyields = (RooRealVar*) iteryields->Next();//only inherits things from TObject unless class specified vector<double> Y, E;//holds yields and associated errors vector<TString> YS, ES;//holds strings of the corresponding yields int j=0;//count vector position int jS=0, jL=0;//these hold the position of the S and L results;initialized in case there is no nsigS or nsigL while(varyields){//loop over yields TString varname = varyields->GetName(); TString vartitle = varyields->GetTitle(); double varval = varyields->getVal(); Y.push_back(varval); double lo = varyields->getErrorLo(); double hi = varyields->getErrorHi(); E.push_back(TMath::Max(fabs(lo),hi)); YS.push_back(Form("%f",Y[j])); ES.push_back(Form("%f",E[j])); if(varname=="nsigS") jS=j; if(varname=="nsigL") jL=j; outputtext = vartitle+" = "+YS[j]+" +/- "+ES[j]; cout<<outputtext<<endl; textfile<<outputtext<<endl; //txt->AddText(outputtext); varyields = (RooRealVar*) iteryields->Next(); j++; } //S/L double result = Y[jS]/Y[jL]; cout<<"result declared"<<endl; double E_result = TMath::Abs(result)*sqrt(pow(E[jS]/Y[jS],2)+pow(E[jL]/Y[jL],2)); cout<<"E_result declared"<<endl; TString resultstring = Form("%E",result); TString E_resultstring = Form("%E",E_result); outputtext = "Y_{#Sigma^{0}}/Y_{#Lambda} = "+resultstring+" +/- "+E_resultstring; cout<<outputtext<<endl; textfile<<outputtext<<endl; //txt->AddText(outputtext); double resultlimit = (Y[jS]+E[jS])/(Y[jL]-E[jL]); outputtext = Form("%E",resultlimit); outputtext = "limit = "+outputtext; cout<<outputtext<<endl; textfile<<outputtext<<endl; //txt->AddText(outputtext); // Create canvas and pads, set style TCanvas *c1 = new TCanvas("c1","data fits",1200,800); TPad *pad1 = new TPad("pad1","pad1",0.0,0.3,1.0,1.0); TPad *pad2 = new TPad("pad2","pad2",0.0,0.0,1.0,0.3); pad1->SetBottomMargin(0); pad2->SetTopMargin(0); pad2->SetBottomMargin(0.5); pad2->SetBorderMode(0); pad1->SetBorderMode(0); c1->SetBorderMode(0); pad2->Draw(); pad1->Draw(); pad1->cd(); framex->SetMinimum(1); framex->SetMaximum(3000); framex->addObject(leg);//add legend to frame //framex->addObject(txt);//add text to frame gPad->SetTopMargin(0.06); pad1->SetLogy(); // pad1->Range(4100,0,6100,0.0005); pad1->Update(); framex->Draw(); // Pull distribution RooPlot *framex2 = mass->frame(); RooHist* hpull = framex->pullHist("Hist","curvetot"); framex2->addPlotable(hpull,"P"); hpull->SetLineColor(kBlack); hpull->SetMarkerColor(kBlack); framex2->SetTitle(0); framex2->GetYaxis()->SetTitle("Pull"); framex2->GetYaxis()->SetTitleSize(0.15); framex2->GetYaxis()->SetLabelSize(0.15); framex2->GetXaxis()->SetTitleSize(0.2); framex2->GetXaxis()->SetLabelSize(0.15); framex2->GetYaxis()->CenterTitle(); framex2->GetYaxis()->SetTitleOffset(0.45); framex2->GetXaxis()->SetTitleOffset(1.1); framex2->GetYaxis()->SetNdivisions(505); framex2->GetYaxis()->SetRangeUser(-8.8,8.8); pad2->cd(); framex2->Draw(); c1->cd(); placeholder = "plots/fit"+fileN+".eps"; c1->Print(placeholder); placeholder = "plots/fit"+fileN+".C"; c1->SaveAs(placeholder); textfile.close(); }
// The actual job void backgroundFits_ggzz_1Dw(int channel, int sqrts, int VBFtag) { TString schannel; if (channel == 1) schannel = "4mu"; else if (channel == 2) schannel = "4e"; else if (channel == 3) schannel = "2e2mu"; else cout << "Not a valid channel: " << schannel << endl; TString ssqrts = (long) sqrts + TString("TeV"); cout << "schannel = " << schannel << " sqrts = " << sqrts << " VBFtag = "<< VBFtag << endl; TString outfile; outfile = "CardFragments/ggzzBackgroundFit_" + ssqrts + "_" + schannel + "_" + Form("%d",int(VBFtag)) + ".txt"; ofstream of(outfile,ios_base::out); gSystem->AddIncludePath("-I$ROOFITSYS/include"); gROOT->ProcessLine(".L ../CreateDatacards/include/tdrstyle.cc"); setTDRStyle(false); gStyle->SetPadLeftMargin(0.16); TString filepath;filepath.Form("AAAOK/ZZ%s/ZZ4lAnalysis.root",schannel.Data()); TFile *f = TFile::Open(filepath); TTree *tree = f->Get("ZZTree/candTree"); RooRealVar* MC_weight = new RooRealVar("MC_weight","MC_weight",0.,2.) ; RooRealVar* ZZMass = new RooRealVar("ZZMass","ZZMass",100,100.,1000.); RooRealVar* NJets30 = new RooRealVar("NJets30","NJets30",0.,5.); RooArgSet ntupleVarSet(*ZZMass,*NJets30,*MC_weight); RooDataSet *set = new RooDataSet("set","set",ntupleVarSet,WeightVar("MC_weight")); //RooArgSet ntupleVarSet(*ZZMass,*NJets30); //RooDataSet *set = new RooDataSet("set","set",ntupleVarSet); Float_t myMC,myMass; Int_t myNJets; int nentries = tree->GetEntries(); Float_t myPt,myJetPt,myJetEta,myJetPhi,myJetMass,myFisher; Int_t myExtralep,myBJets; tree->SetBranchAddress("ZZMass",&myMass); tree->SetBranchAddress("genHEPMCweight",&myMC); tree->SetBranchAddress("nCleanedJetsPt30",&myNJets); tree->SetBranchAddress("ZZPt",&myPt); tree->SetBranchAddress("nExtraLep",&myExtralep); tree->SetBranchAddress("nCleanedJetsPt30BTagged",&myBJets); tree->SetBranchAddress("DiJetDEta",&myFisher); for(int i =0;i<nentries;i++) { tree->GetEntry(i); if(myMass<100.)continue; int cat = category(myExtralep,myPt, myMass,myNJets, myBJets,/* jetpt, jeteta, jetphi, jetmass,*/myFisher); if(VBFtag != cat )continue; ntupleVarSet.setRealValue("ZZMass",myMass); ntupleVarSet.setRealValue("MC_weight",myMC); ntupleVarSet.setRealValue("NJets30",(double)cat); set->add(ntupleVarSet, myMC); } //RooRealVar* ZZLD = new RooRealVar("ZZLD","ZZLD",0.,1.); //char cut[10]; //sprintf(cut,"ZZLD>0.5"); //RooDataSet* set = new RooDataSet("set","set",tree,RooArgSet(*ZZMass,*MC_weight,*ZZLD),cut,"MC_weight"); double totalweight = 0.; for (int i=0 ; i<set->numEntries() ; i++) { set->get(i) ; totalweight += set->weight(); //cout << CMS_zz4l_mass->getVal() << " = " << set->weight() << endl ; } cout << "nEntries: " << set->numEntries() << ", totalweight: " << totalweight << endl; gSystem->Load("libHiggsAnalysisCombinedLimit.so"); //// --------------------------------------- //Background RooRealVar CMS_qqzzbkg_a0("CMS_qqzzbkg_a0","CMS_qqzzbkg_a0",115.3,0.,200.); RooRealVar CMS_qqzzbkg_a1("CMS_qqzzbkg_a1","CMS_qqzzbkg_a1",21.96,0.,200.); RooRealVar CMS_qqzzbkg_a2("CMS_qqzzbkg_a2","CMS_qqzzbkg_a2",122.8,0.,200.); RooRealVar CMS_qqzzbkg_a3("CMS_qqzzbkg_a3","CMS_qqzzbkg_a3",0.03479,0.,1.); RooRealVar CMS_qqzzbkg_a4("CMS_qqzzbkg_a4","CMS_qqzzbkg_a4",185.5,0.,200.); RooRealVar CMS_qqzzbkg_a5("CMS_qqzzbkg_a5","CMS_qqzzbkg_a5",12.67,0.,200.); RooRealVar CMS_qqzzbkg_a6("CMS_qqzzbkg_a6","CMS_qqzzbkg_a6",34.81,0.,100.); RooRealVar CMS_qqzzbkg_a7("CMS_qqzzbkg_a7","CMS_qqzzbkg_a7",0.1393,0.,1.); RooRealVar CMS_qqzzbkg_a8("CMS_qqzzbkg_a8","CMS_qqzzbkg_a8",66.,0.,200.); RooRealVar CMS_qqzzbkg_a9("CMS_qqzzbkg_a9","CMS_qqzzbkg_a9",0.07191,0.,1.); RooggZZPdf_v2* bkg_ggzz = new RooggZZPdf_v2("bkg_ggzz","bkg_ggzz",*ZZMass, CMS_qqzzbkg_a0,CMS_qqzzbkg_a1,CMS_qqzzbkg_a2,CMS_qqzzbkg_a3,CMS_qqzzbkg_a4, CMS_qqzzbkg_a5,CMS_qqzzbkg_a6,CMS_qqzzbkg_a7,CMS_qqzzbkg_a8,CMS_qqzzbkg_a9); //// --------------------------------------- RooFitResult *r1 = bkg_ggzz->fitTo( *set, Save(kTRUE), SumW2Error(kTRUE) );//, Save(kTRUE), SumW2Error(kTRUE)) ; cout << endl; cout << "------- Parameters for " << schannel << " sqrts=" << sqrts << endl; cout << " a0_bkgd = " << CMS_qqzzbkg_a0.getVal() << endl; cout << " a1_bkgd = " << CMS_qqzzbkg_a1.getVal() << endl; cout << " a2_bkgd = " << CMS_qqzzbkg_a2.getVal() << endl; cout << " a3_bkgd = " << CMS_qqzzbkg_a3.getVal() << endl; cout << " a4_bkgd = " << CMS_qqzzbkg_a4.getVal() << endl; cout << " a5_bkgd = " << CMS_qqzzbkg_a5.getVal() << endl; cout << " a6_bkgd = " << CMS_qqzzbkg_a6.getVal() << endl; cout << " a7_bkgd = " << CMS_qqzzbkg_a7.getVal() << endl; cout << " a8_bkgd = " << CMS_qqzzbkg_a8.getVal() << endl; cout << " a9_bkgd = " << CMS_qqzzbkg_a9.getVal() << endl; cout << "---------------------------" << endl << endl; of << "ggZZshape a0_bkgd " << CMS_qqzzbkg_a0.getVal() << endl; of << "ggZZshape a1_bkgd " << CMS_qqzzbkg_a1.getVal() << endl; of << "ggZZshape a2_bkgd " << CMS_qqzzbkg_a2.getVal() << endl; of << "ggZZshape a3_bkgd " << CMS_qqzzbkg_a3.getVal() << endl; of << "ggZZshape a4_bkgd " << CMS_qqzzbkg_a4.getVal() << endl; of << "ggZZshape a5_bkgd " << CMS_qqzzbkg_a5.getVal() << endl; of << "ggZZshape a6_bkgd " << CMS_qqzzbkg_a6.getVal() << endl; of << "ggZZshape a7_bkgd " << CMS_qqzzbkg_a7.getVal() << endl; of << "ggZZshape a8_bkgd " << CMS_qqzzbkg_a8.getVal() << endl; of << "ggZZshape a9_bkgd " << CMS_qqzzbkg_a9.getVal() << endl; of << endl; of.close(); cout << endl << "Output written to: " << outfile << endl; int iLineColor = 1; string lab = "blah"; if (channel == 1) { iLineColor = 2; lab = "4#mu"; } if (channel == 3) { iLineColor = 4; lab = "2e2#mu"; } if (channel == 2) { iLineColor = 6; lab = "4e"; } char lname[192]; sprintf(lname,"gg #rightarrow ZZ #rightarrow %s", lab.c_str() ); char lname2[192]; sprintf(lname2,"Shape Model, %s", lab.c_str() ); // dummy! TF1* dummyF = new TF1("dummyF","1",0.,1.); TH1F* dummyH = new TH1F("dummyH","",1, 0.,1.); dummyF->SetLineColor( iLineColor ); dummyF->SetLineWidth( 2 ); TLegend * box2 = new TLegend(0.5,0.70,0.90,0.90); box2->SetFillColor(0); box2->SetBorderSize(0); box2->AddEntry(dummyH,"Simulation (GG2ZZ) ","pe"); box2->AddEntry(dummyH,lname,""); box2->AddEntry(dummyH,"",""); box2->AddEntry(dummyF,lname2,"l"); TPaveText *pt = new TPaveText(0.15,0.955,0.4,0.99,"NDC"); pt->SetFillColor(0); pt->SetBorderSize(0); pt->AddText("CMS Preliminary 2012"); TPaveText *pt2 = new TPaveText(0.84,0.955,0.99,0.99,"NDC"); pt2->SetFillColor(0); pt2->SetBorderSize(0); // Plot m4l and RooPlot* frameM4l = ZZMass->frame(Title("M4L"),Bins(200)) ; set->plotOn(frameM4l, MarkerStyle(24)) ; bkg_ggzz->plotOn(frameM4l,LineColor(iLineColor)) ; set->plotOn(frameM4l) ; //comaprison with different shape, if needed (uncommenting also the code above) //bkg_ggzz_bkgd->plotOn(frameM4l,LineColor(1),NormRange("largerange")) ; frameM4l->GetXaxis()->SetTitle("m_{4l} [GeV]"); frameM4l->GetYaxis()->SetTitle("a.u."); //frameM4l->GetYaxis()->SetRangeUser(0,0.03); //if(channel == 3)frameM4l->GetYaxis()->SetRangeUser(0,0.05); //if(VBFtag<2){ // if(channel == 3)frameM4l->GetYaxis()->SetRangeUser(0,0.01); // else frameM4l->GetYaxis()->SetRangeUser(0,0.005); //} frameM4l->GetXaxis()->SetRangeUser(100,1000); TCanvas *c = new TCanvas("c","c",800,600); c->cd(); frameM4l->Draw(); box2->Draw(); pt->Draw(); pt2->Draw(); TString outputPath = "bkgFigs"; outputPath = outputPath+ (long) sqrts + "TeV/"; TString outputName; outputName = outputPath + "bkgggzz_" + schannel + "_" + Form("%d",int(VBFtag)); c->SaveAs(outputName + ".eps"); c->SaveAs(outputName + ".png"); c->SaveAs(outputName + ".root"); delete c; frameM4l->GetXaxis()->SetRangeUser(100,200); TCanvas *c = new TCanvas("c","c",800,600); c->cd(); frameM4l->Draw(); box2->Draw(); pt->Draw(); pt2->Draw(); TString outputPath = "bkgFigs"; outputPath = outputPath+ (long) sqrts + "TeV/"; TString outputName; outputName = outputPath + "bkgggzz_lowZoom_" + schannel + "_" + Form("%d",int(VBFtag)); c->SaveAs(outputName + ".eps"); c->SaveAs(outputName + ".png"); c->SaveAs(outputName + ".root"); delete c; }
exampleScript() { gSystem->CompileMacro("betaHelperFunctions.h" ,"kO") ; gSystem->CompileMacro("RooNormalFromFlatPdf.cxx" ,"kO") ; gSystem->CompileMacro("RooBetaInverseCDF.cxx" ,"kO") ; gSystem->CompileMacro("RooBetaPrimeInverseCDF.cxx" ,"kO") ; gSystem->CompileMacro("RooCorrelatedBetaGeneratorHelper.cxx" ,"kO") ; gSystem->CompileMacro("RooCorrelatedBetaPrimeGeneratorHelper.cxx" ,"kO") ; gSystem->CompileMacro("rooFitBetaHelperFunctions.h","kO") ; TFile betaTest("betaTest.root","RECREATE"); betaTest.cd(); RooWorkspace workspace("workspace"); TString correlatedName("testVariable"); TString observables("observables"); TString nuisances("nuisances"); RooAbsArg* betaOne = getCorrelatedBetaConstraint(workspace,"betaOne","", 0.5 , 0.1 , observables, nuisances, correlatedName ); printf("\n\n *** constraint name is %s from betaOne and %s\n\n", betaOne->GetName(), correlatedName.Data() ) ; RooAbsArg* betaTwo = getCorrelatedBetaConstraint(workspace,"betaTwo","", 0 , 0 , observables, nuisances, correlatedName ); RooAbsArg* betaThree = getCorrelatedBetaConstraint(workspace,"betaThree","", 0.2 , 0.01 , observables, nuisances, correlatedName ); RooAbsArg* betaFour = getCorrelatedBetaConstraint(workspace,"betaFour","", 0.7 , 0.1 , observables, nuisances, correlatedName ); RooAbsArg* betaFourC = getCorrelatedBetaConstraint(workspace,"betaFourC","", 0.7 , 0.1 , observables, nuisances, correlatedName, kTRUE ); RooAbsArg* betaPrimeOne = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeOne","", 1.0 , 0.5 , observables, nuisances, correlatedName ); RooAbsArg* betaPrimeOneC = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeOneC","", 1.0 , 0.5 , observables, nuisances, correlatedName, kTRUE ); RooAbsArg* betaPrimeTwo = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeTwo","", 0.7 , 0.5 , observables, nuisances, correlatedName ); RooAbsArg* betaPrimeThree = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeThree","", 0.1 , 0.05 , observables, nuisances, correlatedName ); RooAbsArg* betaPrimeFour = getCorrelatedBetaPrimeConstraint(workspace,"betaPrimeFour","", 7 , 1 , observables, nuisances, correlatedName ); RooRealVar* correlatedParameter = workspace.var(correlatedName); RooAbsPdf* normalFromFlat = workspace.pdf(correlatedName+"_Constraint"); RooDataSet* data = normalFromFlat->generate(RooArgSet(*correlatedParameter),1e5); data->addColumn(*normalFromFlat); data->addColumn(*betaOne); data->addColumn(*betaTwo); data->addColumn(*betaThree); data->addColumn(*betaFour); data->addColumn(*betaFourC); data->addColumn(*betaPrimeOne); data->addColumn(*betaPrimeTwo); data->addColumn(*betaPrimeThree); data->addColumn(*betaPrimeFour); data->addColumn(*betaPrimeOneC); data->Print("v"); workspace.Print() ; //Setup Plotting Kluges: RooRealVar normalPlotter (correlatedName+"_Constraint" , correlatedName+"_Constraint" ,0,1); RooPlot* normalPlot = normalPlotter.frame(); data->plotOn(normalPlot); RooRealVar betaOnePlotter ("betaOne_BetaInverseCDF" ,"betaOne_BetaInverseCDF" ,0,1); RooRealVar betaTwoPlotter ("betaTwo_BetaInverseCDF" ,"betaTwo_BetaInverseCDF" ,0,1); RooRealVar betaThreePlotter("betaThree_BetaInverseCDF","betaThree_BetaInverseCDF",0,1); RooRealVar betaFourPlotter ("betaFour_BetaInverseCDF" ,"betaFour_BetaInverseCDF" ,0,1); RooRealVar betaFourCPlotter ("betaFourC_BetaInverseCDF" ,"betaFourC_BetaInverseCDF" ,0,1); RooRealVar betaPrimeOnePlotter ("betaPrimeOne_BetaPrimeInverseCDF" ,"betaPrimeOne_BetaPrimeInverseCDF" ,0,4); RooRealVar betaPrimeOneCPlotter ("betaPrimeOneC_BetaPrimeInverseCDF" ,"betaPrimeOneC_BetaPrimeInverseCDF" ,0,4); RooRealVar betaPrimeTwoPlotter ("betaPrimeTwo_BetaPrimeInverseCDF" ,"betaPrimeTwo_BetaPrimeInverseCDF" ,0,4); RooRealVar betaPrimeThreePlotter("betaPrimeThree_BetaPrimeInverseCDF","betaPrimeThree_BetaPrimeInverseCDF",0,0.3); RooRealVar betaPrimeFourPlotter ("betaPrimeFour_BetaPrimeInverseCDF" ,"betaPrimeFour_BetaPrimeInverseCDF" ,4,12); RooPlot* betaOnePlot = betaOnePlotter .frame(); RooPlot* betaTwoPlot = betaTwoPlotter .frame(); RooPlot* betaThreePlot = betaThreePlotter.frame(); RooPlot* betaFourPlot = betaFourPlotter .frame(); RooPlot* betaFourCPlot = betaFourCPlotter .frame(); data->plotOn(betaOnePlot ); data->plotOn(betaTwoPlot ); data->plotOn(betaThreePlot); data->plotOn(betaFourPlot ); data->plotOn(betaFourCPlot ); RooPlot* betaPrimeOnePlot = betaPrimeOnePlotter .frame(); RooPlot* betaPrimeOneCPlot = betaPrimeOneCPlotter .frame(); RooPlot* betaPrimeTwoPlot = betaPrimeTwoPlotter .frame(); RooPlot* betaPrimeThreePlot = betaPrimeThreePlotter.frame(); RooPlot* betaPrimeFourPlot = betaPrimeFourPlotter .frame(); data->plotOn(betaPrimeOnePlot ); data->plotOn(betaPrimeOneCPlot ); data->plotOn(betaPrimeTwoPlot ); data->plotOn(betaPrimeThreePlot); data->plotOn(betaPrimeFourPlot ); TCanvas* underlyingVariable = new TCanvas("underlyingVariable","underlyingVariable",800,800); underlyingVariable->Divide(2,2); underlyingVariable->cd(1); RooPlot* underlyingPlot = correlatedParameter->frame(); data->plotOn(underlyingPlot); underlyingPlot->Draw(); underlyingVariable->cd(2); normalPlot->Draw(); underlyingVariable->cd(3); TH2F* underlying = data->createHistogram(*correlatedParameter,normalPlotter,50,50); underlying->Draw("col"); TH2F* legoUnderlying = (TH2F*)underlying->Clone(); underlyingVariable->cd(4); legoUnderlying->Draw("lego"); underlyingVariable->SaveAs("underlyingVariable.pdf"); TCanvas* betaCanvas = new TCanvas("betaCanvas","betaCanvas",800,800); betaCanvas->Divide(3,2); betaCanvas->cd(1); betaOnePlot->Draw(); betaCanvas->cd(2); betaTwoPlot->Draw(); betaCanvas->cd(3); betaThreePlot->Draw(); betaCanvas->cd(4); betaFourPlot->Draw(); betaCanvas->cd(5); betaFourCPlot->Draw(); betaCanvas->SaveAs("betaVariables.pdf"); TCanvas* betaPrimeCanvas = new TCanvas("betaPrimeCanvas","betaPrimeCanvas",1200,800); betaPrimeCanvas->Divide(3,2); betaPrimeCanvas->cd(1); betaPrimeOnePlot->Draw(); betaPrimeCanvas->cd(2); betaPrimeTwoPlot->Draw(); betaPrimeCanvas->cd(3); betaPrimeThreePlot->Draw(); betaPrimeCanvas->cd(4); betaPrimeFourPlot->Draw(); betaPrimeCanvas->cd(5); betaPrimeOneCPlot->Draw(); betaPrimeCanvas->SaveAs("betaPrimeVariables.pdf"); TCanvas* betaCorrelationsCanvas = new TCanvas("betaCorrelationsCanvas","betaCorrelationsCanvas",1600,800); betaCorrelationsCanvas->Divide(4,2); TH2F* oneTwo = data->createHistogram(betaOnePlotter,betaTwoPlotter,30,30); TH2F* oneThree = data->createHistogram(betaOnePlotter,betaThreePlotter,30,30); TH2F* oneFour = data->createHistogram(betaOnePlotter,betaFourPlotter,30,30); TH2F* twoThree = data->createHistogram(betaTwoPlotter,betaThreePlotter,30,30); TH2F* twoFour = data->createHistogram(betaTwoPlotter,betaFourPlotter,30,30); TH2F* threeFour = data->createHistogram(betaThreePlotter,betaFourPlotter,30,30); TH2F* twoFourC = data->createHistogram(betaTwoPlotter,betaFourCPlotter,30,30); TH2F* fourFourC = data->createHistogram(betaFourPlotter,betaFourCPlotter,30,30); betaCorrelationsCanvas->cd(1); oneTwo->DrawCopy("lego"); betaCorrelationsCanvas->cd(2); oneThree->DrawCopy("lego"); betaCorrelationsCanvas->cd(3); oneFour->DrawCopy("lego"); betaCorrelationsCanvas->cd(4); twoThree->DrawCopy("lego"); betaCorrelationsCanvas->cd(5); twoFour->DrawCopy("lego"); betaCorrelationsCanvas->cd(6); threeFour->DrawCopy("lego"); betaCorrelationsCanvas->cd(7); twoFourC->DrawCopy("lego"); betaCorrelationsCanvas->cd(8); fourFourC->DrawCopy("lego"); betaCorrelationsCanvas->SaveAs("betaCorrelations.pdf"); TCanvas* betaPrimeCorrelationsCanvas = new TCanvas("betaPrimeCorrelationsCanvas","betaPrimeCorrelationsCanvas",1600,800); betaPrimeCorrelationsCanvas->Divide(4,2); TH2F* oneTwo = data->createHistogram(betaPrimeOnePlotter,betaPrimeTwoPlotter,30,30); TH2F* oneThree = data->createHistogram(betaPrimeOnePlotter,betaPrimeThreePlotter,30,30); TH2F* oneFour = data->createHistogram(betaPrimeOnePlotter,betaPrimeFourPlotter,30,30); TH2F* twoThree = data->createHistogram(betaPrimeTwoPlotter,betaPrimeThreePlotter,30,30); TH2F* twoFour = data->createHistogram(betaPrimeTwoPlotter,betaPrimeFourPlotter,30,30); TH2F* threeFour = data->createHistogram(betaPrimeThreePlotter,betaPrimeFourPlotter,30,30); TH2F* oneOneC = data->createHistogram(betaPrimeOnePlotter,betaPrimeOneCPlotter,30,30); betaPrimeCorrelationsCanvas->cd(1); oneTwo->DrawCopy("lego"); betaPrimeCorrelationsCanvas->cd(2); oneThree->DrawCopy("lego"); betaPrimeCorrelationsCanvas->cd(3); oneFour->DrawCopy("lego"); betaPrimeCorrelationsCanvas->cd(4); twoThree->DrawCopy("lego"); betaPrimeCorrelationsCanvas->cd(5); twoFour->DrawCopy("lego"); betaPrimeCorrelationsCanvas->cd(6); threeFour->DrawCopy("lego"); betaPrimeCorrelationsCanvas->cd(7); oneOneC->DrawCopy("lego"); betaPrimeCorrelationsCanvas->SaveAs("betaPrimeCorrelations.pdf"); RooProdPdf totalPdf("totalPdf","totalPdf",workspace.allPdfs()); totalPdf.Print("v"); RooArgSet* observableSet = workspace.set("observables"); observableSet->Print(); RooDataSet* allDataOne = totalPdf.generate(*observableSet,1); allDataOne->Print("v"); correlatedParameter->setVal(0.25); RooDataSet* allDataTwo = totalPdf.generate(*observableSet,1); allDataTwo->Print("v"); correlatedParameter->setVal(0.75); RooDataSet* allDataThree = totalPdf.generate(*observableSet,1); allDataThree->Print("v"); //Testing for extreme values! for(int i = 0; i< 101; i++) { correlatedParameter->setVal((double)i/100.); cout << "Correlation parameter has value of " << correlatedParameter->getVal(); cout << " and the pdf has an unnormalized value of " << normalFromFlat->getVal() << endl; } }
int DiagnosisMacro(int Nbins = 10, int Nsigma = 10, int CPUused = 1, TString Filename = "FIT_DATA_Psi2SJpsi_PPPrompt_Bkg_SecondOrderChebychev_pt65300_rap016_cent0200_262620_263757.root", TString Outputdir = "./") //Nbins: Number of points for which to calculate profile likelihood. Time required is about (1/CPU) minutes per point per parameter. 0 means do plain likelihood only //Nsigma: The range in which the scan is performed (value-Nsigma*sigma, value+Nsigma*sigma) //CPUused: anything larger than 1 causes weird fit results on my laptop, runs fine on lxplus with more (16) { // R e a d w o r k s p a c e f r o m f i l e // ----------------------------------------------- // Open input file with workspace //Filename = "FIT_DATA_Psi2SJpsi_PP_Jpsi_DoubleCrystalBall_Psi2S_DoubleCrystalBall_Bkg_Chebychev2_pt6590_rap016_cent0200.root"; //Filename = "FIT_DATA_Psi2SJpsi_PbPb_Jpsi_DoubleCrystalBall_Psi2S_DoubleCrystalBall_Bkg_Chebychev1_pt6590_rap016_cent0200.root"; TFile *f = new TFile(Filename); // Retrieve workspace from file RooWorkspace* w = (RooWorkspace*)f->Get("workspace"); // Retrieve x,model and data from workspace RooRealVar* x = w->var("invMass"); RooAbsPdf* model = w->pdf("simPdf_syst"); if (model == 0) { model = w->pdf("simPdf"); } if (model == 0) { model = w->pdf("pdfMASS_Tot_PP"); } if (model == 0) { model = w->pdf("pdfMASS_Tot_PbPb"); } if (model == 0) { cout << "[ERROR] pdf failed to load from the workspace" << endl; return false; } RooAbsData* data = w->data("dOS_DATA"); if (data == 0) { data = w->data("dOS_DATA_PP"); } if (data == 0) { data = w->data("dOS_DATA_PbPb"); } if (data == 0) { cout << "[ERROR] data failed to load from the workspace" << endl; return false; } // Print structure of composite p.d.f. model->Print("t"); /* // P l o t m o d e l // --------------------------------------------------------- // Plot data and PDF overlaid RooPlot* xframe = x->frame(Title("J/psi Model and Data")); data->plotOn(xframe); model->plotOn(xframe); // Draw the frame on the canvas TCanvas* c2 = new TCanvas("PlotModel", "PlotModel", 1000, 1000); gPad->SetLeftMargin(0.15); xframe->GetYaxis()->SetTitleOffset(2.0); xframe->Draw();//*/ ///// Check parameters RooArgSet* paramSet1 = model->getDependents(data); paramSet1->Print("v"); // Just check RooArgSet* paramSet2 = model->getParameters(data); paramSet2->Print("v"); int Nparams = paramSet2->getSize(); cout << "Number of parameters: " << Nparams<<endl<<endl; // C o n s t r u c t p l a i n l i k e l i h o o d // --------------------------------------------------- // Construct unbinned likelihood RooAbsReal* nll = model->createNLL(*data, NumCPU(CPUused)); // Minimize likelihood w.r.t all parameters before making plots RooMinuit(*nll).migrad(); ////////////////////////////////////////////////////// /////////////////// L O O P O V E R P A R A M E T E R S ///////////////////////////////////////////////////// /// Set up loop over parameters TString ParamName; double ParamValue; double ParamError; double ParamLimitLow; double ParamLimitHigh; double FitRangeLow; double FitRangeHigh; RooRealVar* vParam; int counter = 0; // Loop start TIterator* iter = paramSet2->createIterator(); TObject* var = iter->Next(); while (var != 0) { counter++; ParamName = var->GetName(); vParam = w->var(ParamName); ParamValue = vParam->getVal(); ParamError = vParam->getError(); ParamLimitLow = vParam->getMin(); ParamLimitHigh = vParam->getMax(); cout << ParamName << " has value " << ParamValue << " with error: " << ParamError << " and limits: " << ParamLimitLow << " to " << ParamLimitHigh << endl << endl; if (ParamError == 0) { //Skipping fixed parameters cout << "Parameter was fixed, skipping its fitting" << endl; cout << endl << "DONE WITH " << counter << " PARAMETER OUT OF " << Nparams << endl << endl; var = iter->Next(); continue; } // determining fit range: Nsigma sigma on each side unless it would be outside of parameter limits if ((ParamValue - Nsigma * ParamError) > ParamLimitLow) { FitRangeLow = (ParamValue - Nsigma * ParamError); } else { FitRangeLow = ParamLimitLow; } if ((ParamValue + Nsigma * ParamError) < ParamLimitHigh) { FitRangeHigh = (ParamValue + Nsigma * ParamError); } else { FitRangeHigh = ParamLimitHigh; } // P l o t p l a i n l i k e l i h o o d a n d C o n s t r u c t p r o f i l e l i k e l i h o o d // --------------------------------------------------- RooPlot* frame1; RooAbsReal* pll=NULL; if (Nbins != 0) { frame1 = vParam->frame(Bins(Nbins), Range(FitRangeLow, FitRangeHigh), Title(TString::Format("LL and profileLL in %s", ParamName.Data()))); nll->plotOn(frame1, ShiftToZero()); pll = nll->createProfile(*vParam); // Plot the profile likelihood pll->plotOn(frame1, LineColor(kRed), RooFit::Precision(-1)); } else { //Skip profile likelihood frame1 = vParam->frame(Bins(10), Range(FitRangeLow, FitRangeHigh), Title(TString::Format("LL and profileLL in %s", ParamName.Data()))); nll->plotOn(frame1, ShiftToZero()); } // D r a w a n d s a v e p l o t s // ----------------------------------------------------------------------- // Adjust frame maximum for visual clarity frame1->SetMinimum(0); frame1->SetMaximum(20); TCanvas* c = new TCanvas("CLikelihoodResult", "CLikelihoodResult", 800, 600); c->cd(1); gPad->SetLeftMargin(0.15); frame1->GetYaxis()->SetTitleOffset(1.4); frame1->Draw(); TLegend* leg = new TLegend(0.70, 0.70, 0.95, 0.88, ""); leg->SetFillColor(kWhite); leg->SetBorderSize(0); leg->SetTextSize(0.035); TLegendEntry *le1 = leg->AddEntry(nll, "Plain likelihood", "l"); le1->SetLineColor(kBlue); le1->SetLineWidth(3); TLegendEntry *le2 = leg->AddEntry(pll, "Profile likelihood", "l"); le2->SetLineColor(kRed); le2->SetLineWidth(3); leg->Draw("same"); //Save plot TString StrippedName = TString(Filename(Filename.Last('/')+1,Filename.Length())); StrippedName = StrippedName.ReplaceAll(".root",""); cout << StrippedName << endl; gSystem->mkdir(Form("%s/root/%s", Outputdir.Data(), StrippedName.Data()), kTRUE); c->SaveAs(Form("%s/root/%s/Likelihood_scan_%s.root", Outputdir.Data(), StrippedName.Data(), ParamName.Data())); gSystem->mkdir(Form("%s/pdf/%s", Outputdir.Data(), StrippedName.Data()), kTRUE); c->SaveAs(Form("%s/pdf/%s/Likelihood_scan_%s.pdf", Outputdir.Data(), StrippedName.Data(), ParamName.Data())); gSystem->mkdir(Form("%s/png/%s", Outputdir.Data(), StrippedName.Data()), kTRUE); c->SaveAs(Form("%s/png/%s/Likelihood_scan_%s.png", Outputdir.Data(), StrippedName.Data(), ParamName.Data())); delete c; delete frame1; if (pll) delete pll; cout << endl << "DONE WITH " << counter << " PARAMETER OUT OF " << Nparams << endl << endl; //if (counter == 2){ break; } //Exit - for testing var = iter->Next(); } // End of the loop return true; }
void rf208_convolution() { // S e t u p c o m p o n e n t p d f s // --------------------------------------- // Construct observable RooRealVar t("t","t",-10,30) ; // Construct landau(t,ml,sl) ; RooRealVar ml("ml","mean bw",5.,-20,20) ; RooRealVar sl("sl","sigma bw",1,0.1,10) ; RooBreitWigner bw("bw","bw",t,ml,sl) ; // Construct gauss(t,mg,sg) RooRealVar mg("mg","mg",0) ; RooRealVar sg("sg","sg",2,0.1,10) ; RooGaussian gauss("gauss","gauss",t,mg,sg) ; // C o n s t r u c t c o n v o l u t i o n p d f // --------------------------------------- // Set #bins to be used for FFT sampling to 10000 t.setBins(10000,"cache") ; // Construct landau (x) gauss RooFFTConvPdf lxg("lxg","bw (X) gauss",t,bw,gauss) ; // S a m p l e , f i t a n d p l o t c o n v o l u t e d p d f // ---------------------------------------------------------------------- // Sample 1000 events in x from gxlx RooDataSet* data = lxg.generate(t,10000) ; // Fit gxlx to data lxg.fitTo(*data) ; // Plot data, landau pdf, landau (X) gauss pdf RooPlot* frame = t.frame(Title("landau (x) gauss convolution")) ; data->plotOn(frame) ; lxg.plotOn(frame) ; bw.plotOn(frame,LineStyle(kDashed)) ; // Draw frame on canvas new TCanvas("rf208_convolution","rf208_convolution",600,600) ; gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.4) ; frame->Draw() ; //add a variable to the dataset RooFormulaVar *r_formula = new RooFormulaVar("r_formula","","@0",t); RooRealVar* r = (RooRealVar*) data->addColumn(*r_formula); r->SetName("r"); r->SetTitle("r"); RooDataSet* data_r =(RooDataSet*) data->reduce(*r, ""); r->setRange("sigrange",-10.,30.); RooPlot* r_frame = r->frame(Range("sigRange"),Title(" r (x) gauss convolution")) ; data_r->plotOn(r_frame, MarkerColor(kRed)); r_frame->GetXaxis()->SetRangeUser(-10., 30.); r_frame->Draw() ; }
vector<Double_t*> simFit(bool makeSoupFit_ = false, const string tnp_ = "etoTauMargLooseNoCracks70", const string category_ = "tauAntiEMVA", const string bin_ = "abseta<1.5", const float binCenter_ = 0.75, const float binWidth_ = 0.75, const float xLow_=60, const float xHigh_=120, bool SumW2_ = false, bool verbose_ = true){ vector<Double_t*> out; //return out; //TFile *test = new TFile( outFile->GetName(),"UPDATE"); // output file TFile *test = new TFile( Form("EtoTauPlotsFit_%s_%s_%f.root",tnp_.c_str(),category_.c_str(),binCenter_),"RECREATE"); test->mkdir(Form("bin%f",binCenter_)); TCanvas *c = new TCanvas("fitCanvas",Form("fitCanvas_%s_%s",tnp_.c_str(),bin_.c_str()),10,30,650,600); c->SetGrid(0,0); c->SetFillStyle(4000); c->SetFillColor(10); c->SetTicky(); c->SetObjectStat(0); TCanvas *c2 = new TCanvas("fitCanvasTemplate",Form("fitCanvasTemplate_%s_%s",tnp_.c_str(),bin_.c_str()),10,30,650,600); c2->SetGrid(0,0); c2->SetFillStyle(4000); c2->SetFillColor(10); c2->SetTicky(); c2->SetObjectStat(0); // input files TFile fsup("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_soup.root"); TFile fbkg("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_soup_bkg.root"); TFile fsgn("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_soup_sgn.root"); TFile fdat("/data_CMS/cms/lbianchini/tagAndProbe/trees/38XWcut/testNewWriteFromPAT_Data.root"); // data from 2iter: //TFile fdat("/data_CMS/cms/lbianchini/35pb/testNewWriteFromPAT_Data.root"); //********************** signal only tree *************************/ TTree *fullTreeSgn = (TTree*)fsgn.Get((tnp_+"/fitter_tree").c_str()); TH1F* hSall = new TH1F("hSall","",1,0,150); TH1F* hSPall = new TH1F("hSPall","",1,0,150); TH1F* hS = new TH1F("hS","",1,0,150); TH1F* hSP = new TH1F("hSP","",1,0,150); fullTreeSgn->Draw("mass>>hS",Form("weight*(%s && mass>%f && mass<%f && mcTrue && signalPFChargedHadrCands<1.5)",bin_.c_str(),xLow_,xHigh_)); fullTreeSgn->Draw("mass>>hSall",Form("weight*(%s && mass>%f && mass<%f)",bin_.c_str(),xLow_,xHigh_)); float SGNtrue = hS->Integral(); float SGNall = hSall->Integral(); fullTreeSgn->Draw("mass>>hSP",Form("weight*(%s && %s>0 && mass>%f && mass<%f && mcTrue && signalPFChargedHadrCands<1.5 )",bin_.c_str(),category_.c_str(),xLow_,xHigh_)); fullTreeSgn->Draw("mass>>hSPall",Form("weight*(%s && %s>0 && mass>%f && mass<%f && signalPFChargedHadrCands<1.5 )",bin_.c_str(),category_.c_str(),xLow_,xHigh_)); float SGNtruePass = hSP->Integral(); float SGNallPass = hSPall->Integral(); //********************** background only tree *************************// TTree *fullTreeBkg = (TTree*)fbkg.Get((tnp_+"/fitter_tree").c_str()); TH1F* hB = new TH1F("hB","",1,0,150); TH1F* hBP = new TH1F("hBP","",1,0,150); fullTreeBkg->Draw("mass>>hB",Form("weight*(%s && mass>%f && mass<%f && signalPFChargedHadrCands<1.5 )",bin_.c_str(),xLow_,xHigh_)); float BKG = hB->Integral(); float BKGUnWeighted = hB->GetEntries(); fullTreeBkg->Draw("mass>>hBP",Form("weight*(%s && %s>0 && mass>%f && mass<%f && signalPFChargedHadrCands<1.5 )",bin_.c_str(),category_.c_str(),xLow_,xHigh_)); float BKGPass = hBP->Integral(); float BKGUnWeightedPass = hBP->GetEntries(); float BKGFail = BKG-BKGPass; cout << "*********** BKGFail " << BKGFail << endl; //********************** soup tree *************************// TTree *fullTreeSoup = (TTree*)fsup.Get((tnp_+"/fitter_tree").c_str()); //********************** data tree *************************// TTree *fullTreeData = (TTree*)fdat.Get((tnp_+"/fitter_tree").c_str()); //********************** workspace ***********************// RooWorkspace *w = new RooWorkspace("w","w"); // tree variables to be imported w->factory("mass[30,120]"); w->factory("weight[0,10000]"); w->factory("abseta[0,2.5]"); w->factory("pt[0,200]"); w->factory("mcTrue[0,1]"); w->factory("signalPFChargedHadrCands[0,10]"); w->factory((category_+"[0,1]").c_str()); // background pass pdf for MC w->factory("RooExponential::McBackgroundPdfP(mass,McCP[0,-10,10])"); // background fail pdf for MC w->factory("RooExponential::McBackgroundPdfF(mass,McCF[0,-10,10])"); // background pass pdf for Data w->factory("RooExponential::DataBackgroundPdfP(mass,DataCP[0,-10,10])"); // background fail pdf for Data w->factory("RooExponential::DataBackgroundPdfF(mass,DataCF[0,-10,10])"); // fit parameters for background w->factory("McEfficiency[0.04,0,1]"); w->factory("McNumSgn[0,1000000]"); w->factory("McNumBkgP[0,100000]"); w->factory("McNumBkgF[0,100000]"); w->factory("expr::McNumSgnP('McEfficiency*McNumSgn',McEfficiency,McNumSgn)"); w->factory("expr::McNumSgnF('(1-McEfficiency)*McNumSgn',McEfficiency,McNumSgn)"); w->factory("McPassing[pass=1,fail=0]"); // fit parameters for data w->factory("DataEfficiency[0.1,0,1]"); w->factory("DataNumSgn[0,1000000]"); w->factory("DataNumBkgP[0,1000000]"); w->factory("DataNumBkgF[0,10000]"); w->factory("expr::DataNumSgnP('DataEfficiency*DataNumSgn',DataEfficiency,DataNumSgn)"); w->factory("expr::DataNumSgnF('(1-DataEfficiency)*DataNumSgn',DataEfficiency,DataNumSgn)"); w->factory("DataPassing[pass=1,fail=0]"); RooRealVar *weight = w->var("weight"); RooRealVar *abseta = w->var("abseta"); RooRealVar *pt = w->var("pt"); RooRealVar *mass = w->var("mass"); mass->setRange(xLow_,xHigh_); RooRealVar *mcTrue = w->var("mcTrue"); RooRealVar *cut = w->var( category_.c_str() ); RooRealVar *signalPFChargedHadrCands = w->var("signalPFChargedHadrCands"); // build the template for the signal pass sample: RooDataSet templateP("templateP","dataset for signal-pass template", RooArgSet(*mass,*weight,*abseta,*pt,*cut,*mcTrue,*signalPFChargedHadrCands), Import( *fullTreeSgn ), /*WeightVar( *weight ),*/ Cut( Form("(mcTrue && %s>0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()) ) ); // build the template for the signal fail sample: RooDataSet templateF("templateF","dataset for signal-fail template", RooArgSet(*mass,*weight,*abseta,*pt,*cut,*mcTrue,*signalPFChargedHadrCands), Import( *fullTreeSgn ), /*WeightVar( *weight ),*/ Cut( Form("(mcTrue && %s<0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str()) ) ); mass->setBins(24); RooDataHist templateHistP("templateHistP","",RooArgSet(*mass), templateP, 1.0); RooHistPdf TemplateSignalPdfP("TemplateSignalPdfP","",RooArgSet(*mass),templateHistP); w->import(TemplateSignalPdfP); mass->setBins(24); RooDataHist templateHistF("templateHistF","",RooArgSet(*mass),templateF,1.0); RooHistPdf TemplateSignalPdfF("TemplateSignalPdfF","",RooArgSet(*mass),templateHistF); w->import(TemplateSignalPdfF); mass->setBins(10000,"fft"); RooPlot* TemplateFrameP = mass->frame(Bins(24),Title("Template passing")); templateP.plotOn(TemplateFrameP); w->pdf("TemplateSignalPdfP")->plotOn(TemplateFrameP); RooPlot* TemplateFrameF = mass->frame(Bins(24),Title("Template failing")); templateF.plotOn(TemplateFrameF); w->pdf("TemplateSignalPdfF")->plotOn(TemplateFrameF); //w->factory("RooFFTConvPdf::McSignalPdfP(mass,TemplateSignalPdfP,RooTruthModel::McResolModP(mass))"); //w->factory("RooFFTConvPdf::McSignalPdfF(mass,TemplateSignalPdfF,RooTruthModel::McResolModF(mass))"); // FOR GREGORY: PROBLEM WHEN TRY TO USE THE PURE TEMPLATE => RooHistPdf McSignalPdfP("McSignalPdfP","McSignalPdfP",RooArgSet(*mass),templateHistP); RooHistPdf McSignalPdfF("McSignalPdfF","McSignalPdfF",RooArgSet(*mass),templateHistF); w->import(McSignalPdfP); w->import(McSignalPdfF); // FOR GREGORY: FOR DATA, CONVOLUTION IS OK => w->factory("RooFFTConvPdf::DataSignalPdfP(mass,TemplateSignalPdfP,RooGaussian::DataResolModP(mass,DataMeanResP[0.0,-5.,5.],DataSigmaResP[0.5,0.,10]))"); w->factory("RooFFTConvPdf::DataSignalPdfF(mass,TemplateSignalPdfF,RooGaussian::DataResolModF(mass,DataMeanResF[-5.,-10.,10.],DataSigmaResF[0.5,0.,10]))"); //w->factory("RooCBShape::DataSignalPdfF(mass,DataMeanF[91.2,88,95.],DataSigmaF[3,0.5,8],DataAlfaF[1.8,0.,10],DataNF[1.0,1e-06,10])"); //w->factory("RooFFTConvPdf::DataSignalPdfF(mass,RooVoigtian::DataVoigF(mass,DataMeanF[85,80,95],DataWidthF[2.49],DataSigmaF[3,0.5,10]),RooCBShape::DataResolModF(mass,DataMeanResF[0.5,0.,10.],DataSigmaResF[0.5,0.,10],DataAlphaResF[0.5,0.,10],DataNResF[1.0,1e-06,10]))"); //w->factory("SUM::DataSignalPdfF(fVBP[0.5,0,1]*RooBifurGauss::bifF(mass,DataMeanResF[91.2,80,95],sigmaLF[10,0.5,40],sigmaRF[0.]), RooVoigtian::voigF(mass, DataMeanResF, widthF[2.49], sigmaVoigF[5,0.1,10]) )" ); // composite model pass for MC w->factory("SUM::McModelP(McNumSgnP*McSignalPdfP,McNumBkgP*McBackgroundPdfP)"); w->factory("SUM::McModelF(McNumSgnF*McSignalPdfF,McNumBkgF*McBackgroundPdfF)"); // composite model pass for data w->factory("SUM::DataModelP(DataNumSgnP*DataSignalPdfP,DataNumBkgP*DataBackgroundPdfP)"); w->factory("SUM::DataModelF(DataNumSgnF*DataSignalPdfF,DataNumBkgF*DataBackgroundPdfF)"); // simultaneous fir for MC w->factory("SIMUL::McModel(McPassing,pass=McModelP,fail=McModelF)"); // simultaneous fir for data w->factory("SIMUL::DataModel(DataPassing,pass=DataModelP,fail=DataModelF)"); w->Print("V"); w->saveSnapshot("clean", w->allVars()); w->loadSnapshot("clean"); /****************** sim fit to soup **************************/ /////////////////////////////////////////////////////////////// TFile *f = new TFile("dummySoup.root","RECREATE"); TTree* cutTreeSoupP = fullTreeSoup->CopyTree(Form("(%s>0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str())); TTree* cutTreeSoupF = fullTreeSoup->CopyTree(Form("(%s<0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str())); RooDataSet McDataP("McDataP","dataset pass for the soup", RooArgSet(*mass), Import( *cutTreeSoupP ) ); RooDataSet McDataF("McDataF","dataset fail for the soup", RooArgSet(*mass), Import( *cutTreeSoupF ) ); RooDataHist McCombData("McCombData","combined data for the soup", RooArgSet(*mass), Index(*(w->cat("McPassing"))), Import("pass", *(McDataP.createHistogram("histoP",*mass)) ), Import("fail",*(McDataF.createHistogram("histoF",*mass)) ) ) ; RooPlot* McFrameP = 0; RooPlot* McFrameF = 0; RooRealVar* McEffFit = 0; if(makeSoupFit_){ cout << "**************** N bins in mass " << w->var("mass")->getBins() << endl; RooFitResult* ResMcCombinedFit = w->pdf("McModel")->fitTo(McCombData, Extended(1), Minos(1), Save(1), SumW2Error( SumW2_ ), Range(xLow_,xHigh_), NumCPU(4) /*, ExternalConstraints( *(w->pdf("ConstrainMcNumBkgF")) )*/ ); test->cd(Form("bin%f",binCenter_)); ResMcCombinedFit->Write("McFitResults_Combined"); RooArgSet McFitParam(ResMcCombinedFit->floatParsFinal()); McEffFit = (RooRealVar*)(&McFitParam["McEfficiency"]); RooRealVar* McNumSigFit = (RooRealVar*)(&McFitParam["McNumSgn"]); RooRealVar* McNumBkgPFit = (RooRealVar*)(&McFitParam["McNumBkgP"]); RooRealVar* McNumBkgFFit = (RooRealVar*)(&McFitParam["McNumBkgF"]); McFrameP = mass->frame(Bins(24),Title("MC: passing sample")); McCombData.plotOn(McFrameP,Cut("McPassing==McPassing::pass")); w->pdf("McModel")->plotOn(McFrameP,Slice(*(w->cat("McPassing")),"pass"), ProjWData(*(w->cat("McPassing")),McCombData), LineColor(kBlue),Range(xLow_,xHigh_)); w->pdf("McModel")->plotOn(McFrameP,Slice(*(w->cat("McPassing")),"pass"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McSignalPdfP"), LineColor(kRed),Range(xLow_,xHigh_)); w->pdf("McModel")->plotOn(McFrameP,Slice(*(w->cat("McPassing")),"pass"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McBackgroundPdfP"), LineColor(kGreen),Range(xLow_,xHigh_)); McFrameF = mass->frame(Bins(24),Title("MC: failing sample")); McCombData.plotOn(McFrameF,Cut("McPassing==McPassing::fail")); w->pdf("McModel")->plotOn(McFrameF,Slice(*(w->cat("McPassing")),"fail"), ProjWData(*(w->cat("McPassing")),McCombData), LineColor(kBlue),Range(xLow_,xHigh_)); w->pdf("McModel")->plotOn(McFrameF,Slice(*(w->cat("McPassing")),"fail"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McSignalPdfF"), LineColor(kRed),Range(xLow_,xHigh_)); w->pdf("McModel")->plotOn(McFrameF,Slice(*(w->cat("McPassing")),"fail"), ProjWData(*(w->cat("McPassing")),McCombData), Components("McBackgroundPdfF"), LineColor(kGreen),Range(xLow_,xHigh_)); } /////////////////////////////////////////////////////////////// /****************** sim fit to data **************************/ /////////////////////////////////////////////////////////////// TFile *f2 = new TFile("dummyData.root","RECREATE"); TTree* cutTreeDataP = fullTreeData->CopyTree(Form("(%s>0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str())); TTree* cutTreeDataF = fullTreeData->CopyTree(Form("(%s<0.5 && %s && signalPFChargedHadrCands<1.5)",category_.c_str(),bin_.c_str())); RooDataSet DataDataP("DataDataP","dataset pass for the soup", RooArgSet(*mass), Import( *cutTreeDataP ) ); RooDataSet DataDataF("DataDataF","dataset fail for the soup", RooArgSet(*mass), Import( *cutTreeDataF ) ); RooDataHist DataCombData("DataCombData","combined data for the soup", RooArgSet(*mass), Index(*(w->cat("DataPassing"))), Import("pass",*(DataDataP.createHistogram("histoDataP",*mass))),Import("fail",*(DataDataF.createHistogram("histoDataF",*mass)))) ; RooFitResult* ResDataCombinedFit = w->pdf("DataModel")->fitTo(DataCombData, Extended(1), Minos(1), Save(1), SumW2Error( SumW2_ ), Range(xLow_,xHigh_), NumCPU(4)); test->cd(Form("bin%f",binCenter_)); ResDataCombinedFit->Write("DataFitResults_Combined"); RooArgSet DataFitParam(ResDataCombinedFit->floatParsFinal()); RooRealVar* DataEffFit = (RooRealVar*)(&DataFitParam["DataEfficiency"]); RooRealVar* DataNumSigFit = (RooRealVar*)(&DataFitParam["DataNumSgn"]); RooRealVar* DataNumBkgPFit = (RooRealVar*)(&DataFitParam["DataNumBkgP"]); RooRealVar* DataNumBkgFFit = (RooRealVar*)(&DataFitParam["DataNumBkgF"]); RooPlot* DataFrameP = mass->frame(Bins(24),Title("Data: passing sample")); DataCombData.plotOn(DataFrameP,Cut("DataPassing==DataPassing::pass")); w->pdf("DataModel")->plotOn(DataFrameP,Slice(*(w->cat("DataPassing")),"pass"), ProjWData(*(w->cat("DataPassing")),DataCombData), LineColor(kBlue),Range(xLow_,xHigh_)); w->pdf("DataModel")->plotOn(DataFrameP,Slice(*(w->cat("DataPassing")),"pass"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataSignalPdfP"), LineColor(kRed),Range(xLow_,xHigh_)); w->pdf("DataModel")->plotOn(DataFrameP,Slice(*(w->cat("DataPassing")),"pass"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataBackgroundPdfP"), LineColor(kGreen),LineStyle(kDashed),Range(xLow_,xHigh_)); RooPlot* DataFrameF = mass->frame(Bins(24),Title("Data: failing sample")); DataCombData.plotOn(DataFrameF,Cut("DataPassing==DataPassing::fail")); w->pdf("DataModel")->plotOn(DataFrameF,Slice(*(w->cat("DataPassing")),"fail"), ProjWData(*(w->cat("DataPassing")),DataCombData), LineColor(kBlue),Range(xLow_,xHigh_)); w->pdf("DataModel")->plotOn(DataFrameF,Slice(*(w->cat("DataPassing")),"fail"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataSignalPdfF"), LineColor(kRed),Range(xLow_,xHigh_)); w->pdf("DataModel")->plotOn(DataFrameF,Slice(*(w->cat("DataPassing")),"fail"), ProjWData(*(w->cat("DataPassing")),DataCombData), Components("DataBackgroundPdfF"), LineColor(kGreen),LineStyle(kDashed),Range(xLow_,xHigh_)); /////////////////////////////////////////////////////////////// if(makeSoupFit_) c->Divide(2,2); else c->Divide(2,1); c->cd(1); DataFrameP->Draw(); c->cd(2); DataFrameF->Draw(); if(makeSoupFit_){ c->cd(3); McFrameP->Draw(); c->cd(4); McFrameF->Draw(); } c->Draw(); test->cd(Form("bin%f",binCenter_)); c->Write(); c2->Divide(2,1); c2->cd(1); TemplateFrameP->Draw(); c2->cd(2); TemplateFrameF->Draw(); c2->Draw(); test->cd(Form("bin%f",binCenter_)); c2->Write(); // MINOS errors, otherwise HESSE quadratic errors float McErrorLo = 0; float McErrorHi = 0; if(makeSoupFit_){ McErrorLo = McEffFit->getErrorLo()<0 ? McEffFit->getErrorLo() : (-1)*McEffFit->getError(); McErrorHi = McEffFit->getErrorHi()>0 ? McEffFit->getErrorHi() : McEffFit->getError(); } float DataErrorLo = DataEffFit->getErrorLo()<0 ? DataEffFit->getErrorLo() : (-1)*DataEffFit->getError(); float DataErrorHi = DataEffFit->getErrorHi()>0 ? DataEffFit->getErrorHi() : DataEffFit->getError(); float BinomialError = TMath::Sqrt(SGNtruePass/SGNtrue*(1-SGNtruePass/SGNtrue)/SGNtrue); Double_t* truthMC = new Double_t[6]; Double_t* tnpMC = new Double_t[6]; Double_t* tnpData = new Double_t[6]; truthMC[0] = binCenter_; truthMC[1] = binWidth_; truthMC[2] = binWidth_; truthMC[3] = SGNtruePass/SGNtrue; truthMC[4] = BinomialError; truthMC[5] = BinomialError; if(makeSoupFit_){ tnpMC[0] = binCenter_; tnpMC[1] = binWidth_; tnpMC[2] = binWidth_; tnpMC[3] = McEffFit->getVal(); tnpMC[4] = (-1)*McErrorLo; tnpMC[5] = McErrorHi; } tnpData[0] = binCenter_; tnpData[1] = binWidth_; tnpData[2] = binWidth_; tnpData[3] = DataEffFit->getVal(); tnpData[4] = (-1)*DataErrorLo; tnpData[5] = DataErrorHi; out.push_back(truthMC); out.push_back(tnpData); if(makeSoupFit_) out.push_back(tnpMC); test->Close(); //delete c; delete c2; if(verbose_) cout << "returning from bin " << bin_ << endl; return out; }
void Raa3S_Workspace(const char* name_pbpb="chad_ws_fits/centFits/ws_PbPbData_262548_263757_0cent10_0.0pt50.0_0.0y2.4.root", const char* name_pp="chad_ws_fits/centFits/ws_PPData_262157_262328_-1cent1_0.0pt50.0_0.0y2.4.root", const char* name_out="fitresult_combo.root"){ //TFile File(filename); //RooWorkspace * ws = test_combine(name_pbpb, name_pp); TFile *f = new TFile("fitresult_combo_333.root") ; RooWorkspace * ws1 = (RooWorkspace*) f->Get("wcombo"); //File.GetObject("wcombo", ws); ws1->Print(); RooAbsData * data = ws1->data("data"); //dataOS, dataSS // RooDataSet * US_data = (RooDataSet*) data->reduce( "QQsign == QQsign::PlusMinus"); // US_data->SetName("US_data"); // ws->import(* US_data); // RooDataSet * hi_data = (RooDataSet*) US_data->reduce("dataCat == dataCat::hi"); // hi_data->SetName("hi_data"); // ws->import(* hi_data); // hi_data->Print(); RooRealVar* raa3 = new RooRealVar("raa3","R_{AA}(#Upsilon (3S))",0.5,-1,1); RooRealVar* leftEdge = new RooRealVar("leftEdge","leftEdge",0); RooRealVar* rightEdge = new RooRealVar("rightEdge","rightEdge",1); RooGenericPdf step("step", "step", "(@0 >= @1) && (@0 < @2)", RooArgList(*raa3, *leftEdge, *rightEdge)); ws1->import(step); ws1->factory( "Uniform::flat(raa3)" ); //pp Luminosities, Taa and efficiency ratios Systematics ws1->factory( "Taa_hi[5.662e-9]" ); ws1->factory( "Taa_kappa[1.062]" ); // was 1.057 ws1->factory( "expr::alpha_Taa('pow(Taa_kappa,beta_Taa)',Taa_kappa,beta_Taa[0,-5,5])" ); ws1->factory( "prod::Taa_nom(Taa_hi,alpha_Taa)" ); ws1->factory( "Gaussian::constr_Taa(beta_Taa,glob_Taa[0,-5,5],1)" ); ws1->factory( "lumipp_hi[5.4]" ); ws1->factory( "lumipp_kappa[1.037]" ); // was 1.06 ws1->factory( "expr::alpha_lumipp('pow(lumipp_kappa,beta_lumipp)',lumipp_kappa,beta_lumipp[0,-5,5])" ); ws1->factory( "prod::lumipp_nom(lumipp_hi,alpha_lumipp)" ); ws1->factory( "Gaussian::constr_lumipp(beta_lumipp,glob_lumipp[0,-5,5],1)" ); // ws->factory( "effRat1[1]" ); // ws->factory( "effRat2[1]" ); ws1->factory( "effRat3_hi[0.95]" ); ws1->factory( "effRat_kappa[1.054]" ); ws1->factory( "expr::alpha_effRat('pow(effRat_kappa,beta_effRat)',effRat_kappa,beta_effRat[0,-5,5])" ); // ws->factory( "prod::effRat1_nom(effRat1_hi,alpha_effRat)" ); ws1->factory( "Gaussian::constr_effRat(beta_effRat,glob_effRat[0,-5,5],1)" ); // ws->factory( "prod::effRat2_nom(effRat2_hi,alpha_effRat)" ); ws1->factory( "prod::effRat3_nom(effRat3_hi,alpha_effRat)" ); // ws1->factory("Nmb_hi[1.161e9]"); ws1->factory("prod::denominator(Taa_nom,Nmb_hi)"); ws1->factory( "expr::lumiOverTaaNmbmodified('lumipp_nom/denominator',lumipp_nom,denominator)"); RooAbsReal *lumiOverTaaNmbmodified = ws1->function("lumiOverTaaNmbmodified"); //RooFormulaVar *lumiOverTaaNmbmodified = ws->function("lumiOverTaaNmbmodified"); // // RooRealVar *raa1 = ws->var("raa1"); // RooRealVar* nsig1_pp = ws->var("nsig1_pp"); // RooRealVar* effRat1 = ws->function("effRat1_nom"); // RooRealVar *raa2 = ws->var("raa2"); // RooRealVar* nsig2_pp = ws->var("nsig2_pp"); // RooRealVar* effRat2 = ws->function("effRat2_nom"); RooRealVar* nsig3_pp = ws1->var("R_{#frac{3S}{1S}}_pp"); //RooRealVar* nsig3_pp = ws->var("N_{#Upsilon(3S)}_pp"); cout << nsig3_pp << endl; RooAbsReal* effRat3 = ws1->function("effRat3_nom"); //RooRealVar* effRat3 = ws->function("effRat3_nom"); // // RooFormulaVar nsig1_hi_modified("nsig1_hi_modified", "@0*@1*@3/@2", RooArgList(*raa1, *nsig1_pp, *lumiOverTaaNmbmodified, *effRat1)); // ws->import(nsig1_hi_modified); // RooFormulaVar nsig2_hi_modified("nsig2_hi_modified", "@0*@1*@3/@2", RooArgList(*raa2, *nsig2_pp, *lumiOverTaaNmbmodified, *effRat2)); // ws->import(nsig2_hi_modified); RooFormulaVar nsig3_hi_modified("nsig3_hi_modified", "@0*@1*@3/@2", RooArgList(*raa3, *nsig3_pp, *lumiOverTaaNmbmodified, *effRat3)); ws1->import(nsig3_hi_modified); // // background yield with systematics ws1->factory( "nbkg_hi_kappa[1.10]" ); ws1->factory( "expr::alpha_nbkg_hi('pow(nbkg_hi_kappa,beta_nbkg_hi)',nbkg_hi_kappa,beta_nbkg_hi[0,-5,5])" ); ws1->factory( "SUM::nbkg_hi_nom(alpha_nbkg_hi*bkgPdf_hi)" ); ws1->factory( "Gaussian::constr_nbkg_hi(beta_nbkg_hi,glob_nbkg_hi[0,-5,5],1)" ); RooAbsPdf* sig1S_hi = ws1->pdf("sig1S_hi"); //RooAbsPdf* sig1S_hi = ws->pdf("cbcb_hi"); RooAbsPdf* sig2S_hi = ws1->pdf("sig2S_hi"); RooAbsPdf* sig3S_hi = ws1->pdf("sig3S_hi"); RooAbsPdf* LSBackground_hi = ws1->pdf("nbkg_hi_nom"); RooRealVar* nsig1_hi = ws1->var("N_{#Upsilon(1S)}_hi"); RooRealVar* nsig2_hi = ws1->var("R_{#frac{2S}{1S}}_hi"); RooAbsReal* nsig3_hi = ws1->function("nsig3_hi_modified"); //RooFormulaVar* nsig3_hi = ws->function("nsig3_hi_modified"); cout << nsig1_hi << " " << nsig2_hi << " " << nsig3_pp << endl; RooRealVar* norm_nbkg_hi = ws1->var("n_{Bkgd}_hi"); RooArgList pdfs_hi( *sig1S_hi,*sig2S_hi,*sig3S_hi, *LSBackground_hi); RooArgList norms_hi(*nsig1_hi,*nsig2_hi,*nsig3_hi, *norm_nbkg_hi); //////////////////////////////////////////////////////////////////////////////// ws1->factory( "nbkg_pp_kappa[1.03]" ); ws1->factory( "expr::alpha_nbkg_pp('pow(nbkg_pp_kappa,beta_nbkg_pp)',nbkg_pp_kappa,beta_nbkg_pp[0,-5,5])" ); ws1->factory( "SUM::nbkg_pp_nom(alpha_nbkg_pp*bkgPdf_pp)" ); ws1->factory( "Gaussian::constr_nbkg_pp(beta_nbkg_pp,glob_nbkg_pp[0,-5,5],1)" ); RooAbsPdf* sig1S_pp = ws1->pdf("sig1S_pp"); //RooAbsPdf* sig1S_pp = ws1->pdf("cbcb_pp"); RooAbsPdf* sig2S_pp = ws1->pdf("sig2S_pp"); RooAbsPdf* sig3S_pp = ws1->pdf("sig3S_pp"); RooAbsPdf* LSBackground_pp = ws1->pdf("nbkg_pp_nom"); RooRealVar* nsig1_pp = ws1->var("N_{#Upsilon(1S)}_pp"); RooRealVar* nsig2_pp = ws1->var("R_{#frac{2S}{1S}}_pp"); //RooRealVar* nsig2_pp = ws1->var("N_{#Upsilon(2S)}_pp"); // RooRealVar* nsig3_pp = ws1->var("N_{#Upsilon(3S)}_pp"); RooRealVar* norm_nbkg_pp = ws1->var("n_{Bkgd}_pp"); RooArgList pdfs_pp( *sig1S_pp,*sig2S_pp,*sig3S_pp, *LSBackground_pp); RooArgList norms_pp( *nsig1_pp,*nsig2_pp,*nsig3_pp,*norm_nbkg_pp); RooAddPdf model_num("model_num", "model_num", pdfs_hi,norms_hi); ws1->import(model_num); ws1->factory("PROD::model_hi(model_num, constr_nbkg_hi,constr_lumipp,constr_Taa,constr_effRat)"); RooAddPdf model_den("model_den", "model_den", pdfs_pp,norms_pp); ws1->import(model_den); ws1->factory("PROD::model_pp(model_den, constr_nbkg_pp)"); ws1->factory("SIMUL::joint(dataCat,hi=model_hi,pp=model_pp)"); ///////////////////////////////////////////////////////////////////// RooRealVar * pObs = ws1->var("invariantMass"); // get the pointer to the observable RooArgSet obs("observables"); obs.add(*pObs); obs.add( *ws1->cat("dataCat")); // ///////////////////////////////////////////////////////////////////// ws1->var("glob_lumipp")->setConstant(true); ws1->var("glob_Taa")->setConstant(true); ws1->var("glob_effRat")->setConstant(true); ws1->var("glob_nbkg_pp")->setConstant(true); ws1->var("glob_nbkg_hi")->setConstant(true); RooArgSet globalObs("global_obs"); globalObs.add( *ws1->var("glob_lumipp") ); globalObs.add( *ws1->var("glob_Taa") ); globalObs.add( *ws1->var("glob_effRat") ); globalObs.add( *ws1->var("glob_nbkg_hi") ); globalObs.add( *ws1->var("glob_nbkg_pp") ); cout << "66666" << endl; // ws1->Print(); RooArgSet poi("poi"); poi.add( *ws1->var("raa3") ); cout << "77777" << endl; // create set of nuisance parameters RooArgSet nuis("nuis"); nuis.add( *ws1->var("beta_lumipp") ); nuis.add( *ws1->var("beta_nbkg_hi") ); nuis.add( *ws1->var("beta_nbkg_pp") ); nuis.add( *ws1->var("beta_Taa") ); nuis.add( *ws1->var("beta_effRat") ); cout << "88888" << endl; ws1->var("#alpha_{CB}_hi")->setConstant(true); ws1->var("#alpha_{CB}_pp")->setConstant(true); ws1->var("#sigma_{CB1}_hi")->setConstant(true); ws1->var("#sigma_{CB1}_pp")->setConstant(true); ws1->var("#sigma_{CB2}/#sigma_{CB1}_hi")->setConstant(true); ws1->var("#sigma_{CB2}/#sigma_{CB1}_pp")->setConstant(true); //ws1->var("Centrality")->setConstant(true); //delete ws1->var("N_{#varUpsilon(1S)}_hi")->setConstant(true); ws1->var("N_{#varUpsilon(1S)}_pp")->setConstant(true); //ws1->var("N_{#Upsilon(2S)}_hi")->setConstant(true); //ws1->var("N_{#Upsilon(2S)}_pp")->setConstant(true); //ws1->var("N_{#Upsilon(3S)}_pp")->setConstant(true); ws1->var("R_{#frac{2S}{1S}}_hi")->setConstant(true); //new ws1->var("R_{#frac{2S}{1S}}_pp")->setConstant(true); //new ws1->var("R_{#frac{3S}{1S}}_hi")->setConstant(true); //new ws1->var("R_{#frac{3S}{1S}}_pp")->setConstant(true); //new ws1->var("Nmb_hi")->setConstant(true); // ws1->var("QQsign")->setConstant(true); ws1->var("Taa_hi")->setConstant(true); ws1->var("Taa_kappa")->setConstant(true); // ws1->var("beta_Taa")->setConstant(true); // ws1->var("beta_effRat")->setConstant(true); // ws1->var("beta_lumipp")->setConstant(true); // ws1->var("beta_nbkg_hi")->setConstant(true); // ws1->var("beta_nbkg_pp")->setConstant(true); // ws1->var("dataCat")->setConstant(true); ws1->var("decay_hi")->setConstant(true); ws1->var("decay_pp")->setConstant(true); ws1->var("effRat3_hi")->setConstant(true); ws1->var("effRat_kappa")->setConstant(true); // ws1->var("glob_Taa")->setConstant(true); // ws1->var("glob_effRat")->setConstant(true); // ws1->var("glob_lumipp")->setConstant(true); // ws1->var("glob_nbkg_hi")->setConstant(true); // ws1->var("glob_nbkg_pp")->setConstant(true); // ws1->var("invariantMass")->setConstant(true); ws1->var("leftEdge")->setConstant(true); ws1->var("lumipp_hi")->setConstant(true); ws1->var("lumipp_kappa")->setConstant(true); ws1->var("m_{ #varUpsilon(1S)}_hi")->setConstant(true); //ws1->var("mass1S_hi")->setConstant(true); ws1->var("m_{ #varUpsilon(1S)}_pp")->setConstant(true); //ws1->var("mass1S_pp")->setConstant(true); ws1->var("muMinusPt")->setConstant(true); ws1->var("muPlusPt")->setConstant(true); ws1->var("n_{Bkgd}_hi")->setConstant(true); ws1->var("n_{Bkgd}_pp")->setConstant(true); ws1->var("nbkg_hi_kappa")->setConstant(true); ws1->var("nbkg_pp_kappa")->setConstant(true); //ws1->var("n_{CB}")->setConstant(true); //ws1->var("n_{CB}")->setConstant(true); //ws1->var("npow")->setConstant(true); ws1->var("n_{CB}_hi")->setConstant(true); //ws1->var("n_{CB}")->setConstant(true); //ws1->var("npow")->setConstant(true); ws1->var("n_{CB}_pp")->setConstant(true); //ws1->var("n_{CB}")->setConstant(true); //ws1->var("npow")->setConstant(true); // ws1->var("raa3")->setConstant(true); ws1->var("rightEdge")->setConstant(true); ws1->var("sigmaFraction_hi")->setConstant(true); ws1->var("sigmaFraction_pp")->setConstant(true); ws1->var("turnOn_hi")->setConstant(true); ws1->var("turnOn_pp")->setConstant(true); ws1->var("dimuPt")->setConstant(true); //ws1->var("upsPt")->setConstant(true); ws1->var("dimuRapidity")->setConstant(true); //ws1->var("upsRapidity")->setConstant(true); ws1->var("vProb")->setConstant(true); ws1->var("width_hi")->setConstant(true); ws1->var("width_pp")->setConstant(true); // ws1->var("x3raw")->setConstant(true); // RooArgSet fixed_again("fixed_again"); // fixed_again.add( *ws1->var("leftEdge") ); // fixed_again.add( *ws1->var("rightEdge") ); // fixed_again.add( *ws1->var("Taa_hi") ); // fixed_again.add( *ws1->var("Nmb_hi") ); // fixed_again.add( *ws1->var("lumipp_hi") ); // fixed_again.add( *ws1->var("effRat1_hi") ); // fixed_again.add( *ws1->var("effRat2_hi") ); // fixed_again.add( *ws1->var("effRat3_hi") ); // fixed_again.add( *ws1->var("nsig3_pp") ); // fixed_again.add( *ws1->var("nsig1_pp") ); // fixed_again.add( *ws1->var("nbkg_hi") ); // fixed_again.add( *ws1->var("alpha") ); // fixed_again.add( *ws1->var("nbkg_kappa") ); // fixed_again.add( *ws1->var("Taa_kappa") ); // fixed_again.add( *ws1->var("lumipp_kappa") ); // fixed_again.add( *ws1->var("mean_hi") ); // fixed_again.add( *ws1->var("mean_pp") ); // fixed_again.add( *ws1->var("width_hi") ); // fixed_again.add( *ws1->var("turnOn_hi") ); // fixed_again.add( *ws1->var("bkg_a1_pp") ); // fixed_again.add( *ws1->var("bkg_a2_pp") ); // fixed_again.add( *ws1->var("decay_hi") ); // fixed_again.add( *ws1->var("raa1") ); // fixed_again.add( *ws1->var("raa2") ); // fixed_again.add( *ws1->var("nsig2_pp") ); // fixed_again.add( *ws1->var("sigma1") ); // fixed_again.add( *ws1->var("nbkg_pp") ); // fixed_again.add( *ws1->var("npow") ); // fixed_again.add( *ws1->var("muPlusPt") ); // fixed_again.add( *ws1->var("muMinusPt") ); // fixed_again.add( *ws1->var("mscale_hi") ); // fixed_again.add( *ws1->var("mscale_pp") ); // // ws1->Print(); cout << "99999" << endl; // create signal+background Model Config RooStats::ModelConfig sbHypo("SbHypo"); sbHypo.SetWorkspace( *ws1 ); sbHypo.SetPdf( *ws1->pdf("joint") ); sbHypo.SetObservables( obs ); sbHypo.SetGlobalObservables( globalObs ); sbHypo.SetParametersOfInterest( poi ); sbHypo.SetNuisanceParameters( nuis ); sbHypo.SetPriorPdf( *ws1->pdf("step") ); // this is optional // ws1->Print(); ///////////////////////////////////////////////////////////////////// RooAbsReal * pNll = sbHypo.GetPdf()->createNLL( *data,NumCPU(10) ); cout << "111111" << endl; RooMinuit(*pNll).migrad(); // minimize likelihood wrt all parameters before making plots cout << "444444" << endl; RooPlot *framepoi = ((RooRealVar *)poi.first())->frame(Bins(10),Range(0.,0.2),Title("LL and profileLL in raa3")); cout << "222222" << endl; pNll->plotOn(framepoi,ShiftToZero()); cout << "333333" << endl; RooAbsReal * pProfile = pNll->createProfile( globalObs ); // do not profile global observables pProfile->getVal(); // this will do fit and set POI and nuisance parameters to fitted values pProfile->plotOn(framepoi,LineColor(kRed)); framepoi->SetMinimum(0); framepoi->SetMaximum(3); TCanvas *cpoi = new TCanvas(); cpoi->cd(); framepoi->Draw(); cpoi->SaveAs("cpoi.pdf"); ((RooRealVar *)poi.first())->setMin(0.); RooArgSet * pPoiAndNuisance = new RooArgSet("poiAndNuisance"); // pPoiAndNuisance->add(*sbHypo.GetNuisanceParameters()); // pPoiAndNuisance->add(*sbHypo.GetParametersOfInterest()); pPoiAndNuisance->add( nuis ); pPoiAndNuisance->add( poi ); sbHypo.SetSnapshot(*pPoiAndNuisance); RooPlot* xframeSB = pObs->frame(Title("SBhypo")); data->plotOn(xframeSB,Cut("dataCat==dataCat::hi")); RooAbsPdf *pdfSB = sbHypo.GetPdf(); RooCategory *dataCat = ws1->cat("dataCat"); pdfSB->plotOn(xframeSB,Slice(*dataCat,"hi"),ProjWData(*dataCat,*data)); TCanvas *c1 = new TCanvas(); c1->cd(); xframeSB->Draw(); c1->SaveAs("c1.pdf"); delete pProfile; delete pNll; delete pPoiAndNuisance; ws1->import( sbHypo ); ///////////////////////////////////////////////////////////////////// RooStats::ModelConfig bHypo = sbHypo; bHypo.SetName("BHypo"); bHypo.SetWorkspace(*ws1); pNll = bHypo.GetPdf()->createNLL( *data,NumCPU(2) ); RooArgSet poiAndGlobalObs("poiAndGlobalObs"); poiAndGlobalObs.add( poi ); poiAndGlobalObs.add( globalObs ); pProfile = pNll->createProfile( poiAndGlobalObs ); // do not profile POI and global observables ((RooRealVar *)poi.first())->setVal( 0 ); // set raa3=0 here pProfile->getVal(); // this will do fit and set nuisance parameters to profiled values pPoiAndNuisance = new RooArgSet( "poiAndNuisance" ); pPoiAndNuisance->add( nuis ); pPoiAndNuisance->add( poi ); bHypo.SetSnapshot(*pPoiAndNuisance); RooPlot* xframeB = pObs->frame(Title("Bhypo")); data->plotOn(xframeB,Cut("dataCat==dataCat::hi")); RooAbsPdf *pdfB = bHypo.GetPdf(); pdfB->plotOn(xframeB,Slice(*dataCat,"hi"),ProjWData(*dataCat,*data)); TCanvas *c2 = new TCanvas(); c2->cd(); xframeB->Draw(); c2->SaveAs("c2.pdf"); delete pProfile; delete pNll; delete pPoiAndNuisance; // import model config into workspace bHypo.SetWorkspace(*ws1); ws1->import( bHypo ); ///////////////////////////////////////////////////////////////////// ws1->Print(); bHypo.Print(); sbHypo.Print(); // save workspace to file ws1 -> SaveAs(name_out); return; }
void fitSingleMass( const std::string& basedir, float mass, const std::string& width, TGraphErrors* gr_mean, TGraphErrors* gr_sigma, TGraphErrors* gr_width, TGraphErrors* gr_alpha1, TGraphErrors* gr_n1, TGraphErrors* gr_alpha2, TGraphErrors* gr_n2 ) { std::string outdir = "genSignalShapes"; system( Form("mkdir -p %s", outdir.c_str()) ); std::string dataset( Form( "GluGluSpin0ToZGamma_ZToLL_W_%s_M_%.0f_TuneCUEP8M1_13TeV_pythia8", width.c_str(), mass ) ); std::cout << "-> Starting: " << dataset << std::endl; system( Form("ls %s/%s/crab_%s/*/0000/genAna_1.root >> toBeAdded.txt", basedir.c_str(), dataset.c_str(), dataset.c_str() ) ); TChain* tree = new TChain("mt2"); ifstream ifs("toBeAdded.txt"); while( ifs.good() ) { std::string fileName; ifs >> fileName; TString fileName_tstr(fileName); if( !fileName_tstr.Contains("pnfs") ) continue; tree->Add(Form("$DCAP/%s/mt2", fileName.c_str()) ); } system( "rm toBeAdded.txt" ); if( tree->GetEntries()==0 ) return; int ngenPart; tree->SetBranchAddress( "ngenPart", &ngenPart ); float genPart_pt[100]; tree->SetBranchAddress( "genPart_pt", genPart_pt ); float genPart_eta[100]; tree->SetBranchAddress( "genPart_eta", genPart_eta ); float genPart_phi[100]; tree->SetBranchAddress( "genPart_phi", genPart_phi ); float genPart_mass[100]; tree->SetBranchAddress( "genPart_mass", genPart_mass ); int genPart_pdgId[100]; tree->SetBranchAddress( "genPart_pdgId", genPart_pdgId ); int genPart_motherId[100]; tree->SetBranchAddress( "genPart_motherId", genPart_motherId ); int genPart_status[100]; tree->SetBranchAddress( "genPart_status", genPart_status ); RooRealVar* x = new RooRealVar("boss_mass", "boss_mass", mass, 0.5*mass, 1.5*mass ); RooDataSet* data = new RooDataSet( "data", "data", RooArgSet(*x) ); int nentries = tree->GetEntries(); for( int iEntry = 0; iEntry<nentries; ++iEntry ) { if( iEntry % 25000 == 0 ) std::cout << " Entry: " << iEntry << " / " << nentries << std::endl; tree->GetEntry(iEntry); TLorentzVector leptPlus; TLorentzVector leptMinus; TLorentzVector photon; bool foundLeptPlus = false; bool foundLeptMinus = false; bool foundPhoton = false; bool tauEvent = false; for( int iPart=0; iPart<ngenPart; ++iPart ) { if( genPart_status[iPart]!=1 ) continue; if( abs(genPart_pdgId[iPart])==15 ) { tauEvent = true; break; } if( (genPart_pdgId[iPart]==+11 || genPart_pdgId[iPart]==+13) && genPart_motherId[iPart]==23 ) { leptMinus.SetPtEtaPhiM( genPart_pt[iPart], genPart_eta[iPart], genPart_phi[iPart], genPart_mass[iPart] ); foundLeptMinus = true; } if( (genPart_pdgId[iPart]==-11 || genPart_pdgId[iPart]==-13) && genPart_motherId[iPart]==23 ) { leptPlus.SetPtEtaPhiM( genPart_pt[iPart], genPart_eta[iPart], genPart_phi[iPart], genPart_mass[iPart] ); foundLeptPlus = true; } if( genPart_pdgId[iPart]==22 && genPart_motherId[iPart]==25 ) { photon.SetPtEtaPhiM( genPart_pt[iPart], genPart_eta[iPart], genPart_phi[iPart], genPart_mass[iPart] ); foundPhoton = true; } } // for genparts if( tauEvent ) continue; if( !foundLeptPlus || !foundLeptMinus || !foundPhoton ) continue; if( photon.Pt() < 40. ) continue; float ptMax = TMath::Max( leptPlus.Pt(), leptMinus.Pt() ); float ptMin = TMath::Min( leptPlus.Pt(), leptMinus.Pt() ); if( ptMax<25. ) continue; if( ptMin<20. ) continue; if( fabs( photon.Eta() ) > 2.5 ) continue; if( fabs( photon.Eta())>1.44 && fabs( photon.Eta())<1.57 ) continue; if( fabs( leptPlus.Eta() ) > 2.4 ) continue; if( fabs( leptMinus.Eta() ) > 2.4 ) continue; if( photon.DeltaR( leptPlus ) < 0.4 ) continue; if( photon.DeltaR( leptMinus ) < 0.4 ) continue; TLorentzVector zBoson = leptPlus + leptMinus; if( zBoson.M() < 50. ) continue; TLorentzVector boss = zBoson + photon; if( boss.M() < 200. ) continue; if( photon.Pt()/boss.M()< 40./150. ) continue; x->setVal(boss.M()); data->add(RooArgSet(*x)); } //RooRealVar* bw_mean = new RooRealVar( "bw_mean", "Breit-Wigner Mean" , mass, 0.2*mass, 1.8*mass ); //RooRealVar* bw_gamma = new RooRealVar( "bw_gamma", "Breit-Wigner Width", 0.01*mass, 0., 0.3*mass ); //RooBreitWigner* model = new RooBreitWigner( "bw", "Breit-Wigner", *x, *bw_mean, *bw_gamma); // Crystal-Ball RooRealVar mean( "mean", "mean", mass, 0.9*mass, 1.1*mass ); RooRealVar sigma( "sigma", "sigma", 0.015*mass, 0., 0.07*mass ); RooRealVar alpha1( "alpha1", "alpha1", 1.2, 0., 2.5 ); RooRealVar n1( "n1", "n1", 3., 0., 5. ); RooRealVar alpha2( "alpha2", "alpha2", 1.2, 0., 2.5 ); RooRealVar n2( "n2", "n2", 3., 0., 10. ); RooDoubleCBShape* model = new RooDoubleCBShape( "cb", "cb", *x, mean, sigma, alpha1, n1, alpha2, n2 ); model->fitTo( *data ); int npoints = gr_mean->GetN(); gr_mean ->SetPoint( npoints, mass, mean.getVal() ); gr_sigma ->SetPoint( npoints, mass, sigma.getVal() ); gr_width ->SetPoint( npoints, mass, sigma.getVal()/mean.getVal() ); gr_alpha1->SetPoint( npoints, mass, alpha1.getVal() ); gr_alpha2->SetPoint( npoints, mass, alpha2.getVal() ); gr_n1 ->SetPoint( npoints, mass, n1.getVal() ); gr_n2 ->SetPoint( npoints, mass, n2.getVal() ); gr_mean ->SetPointError( npoints, 0., mean.getError() ); gr_sigma ->SetPointError( npoints, 0., sigma.getError() ); gr_width ->SetPointError( npoints, 0., sigma.getError()/mean.getVal() ); gr_alpha1->SetPointError( npoints, 0., alpha1.getError() ); gr_alpha2->SetPointError( npoints, 0., alpha2.getError() ); gr_n1 ->SetPointError( npoints, 0., n1.getError() ); gr_n2 ->SetPointError( npoints, 0., n2.getError() ); //gr_mean ->SetPoint ( npoints, mass, bw_mean->getVal() ); //gr_gamma->SetPoint ( npoints, mass, bw_gamma->getVal() ); //gr_width->SetPoint ( npoints, mass, bw_gamma->getVal()/bw_mean->getVal() ); //gr_mean ->SetPointError( npoints, 0., bw_mean->getError() ); //gr_gamma->SetPointError( npoints, 0., bw_gamma->getError()/bw_mean->getVal() ); //gr_width->SetPointError( npoints, 0., bw_gamma->getError()/bw_mean->getVal() ); RooPlot* plot = x->frame(); data->plotOn(plot); model->plotOn(plot); TCanvas* c1 = new TCanvas( "c1", "", 600, 600 ); c1->cd(); plot->Draw(); c1->SaveAs( Form("%s/fit_m%.0f_%s.eps", outdir.c_str(), mass, width.c_str()) ); c1->SaveAs( Form("%s/fit_m%.0f_%s.pdf", outdir.c_str(), mass, width.c_str()) ); c1->SetLogy(); c1->SaveAs( Form("%s/fit_m%.0f_%s_log.eps", outdir.c_str(), mass, width.c_str()) ); c1->SaveAs( Form("%s/fit_m%.0f_%s_log.pdf", outdir.c_str(), mass, width.c_str()) ); //delete bw_mean; //delete bw_gamma; delete c1; delete data; delete model; delete plot; delete x; }