void trig_pt() { TCanvas *myCan=new TCanvas("myCan","myCan"); myCan->SetGrid(); TFile *f_MC= new TFile("TnP_WptCutToTrig_MCptminus.root","read"); RooDataSet *datasetMC = (RooDataSet*)f_MC->Get("tpTree/Tnp_WptCut_to_Mu15_eta2p1_pt/cnt_eff"); cout<<"ntry: "<<datasetMC->numEntries()<<endl; double XMC[Nbin],XMCerrL[Nbin],XMCerrH[Nbin],YMC[Nbin],YMCerrLo[Nbin],YMCerrHi[Nbin]; for(int i(0); i<datasetMC->numEntries();i++) { const RooArgSet &pointMC=*datasetMC->get(i); RooRealVar &ptMC=pointMC["pt"],&effMC = pointMC["efficiency"]; XMC[i]=ptMC.getVal(); XMCerrL[i]=-ptMC.getAsymErrorLo(); XMCerrH[i]=ptMC.getAsymErrorHi(); YMC[i]=effMC.getVal(); YMCerrLo[i]=-effMC.getAsymErrorLo(); YMCerrHi[i]=effMC.getAsymErrorHi(); } grMC=new TGraphAsymmErrors(11,XMC,YMC,XMCerrL,XMCerrH,YMCerrLo,YMCerrHi); grMC->SetLineColor(kRed); grMC->SetMarkerColor(kRed); grMC->Draw("AP"); //grMC->Draw("psame"); myCan->SaveAs("trig_McMinus_pt.png"); myCan->SaveAs("trig_McMinus_pt.eps"); }
void glbToId_eta() { TCanvas *myCan=new TCanvas("myCan","myCan"); myCan->SetGrid(); TFile *f_MC= new TFile("TnP_GlbToID_MCetaplus_WptTight2012_eta.root","read"); RooDataSet *datasetMC = (RooDataSet*)f_MC->Get("tpTree/WptTight2012_eta/fit_eff"); //RooDataSet *datasetMC = (RooDataSet*)f_MC->Get("tpTree/WptTight2012_eta/cnt_eff"); cout<<"ntry: "<<datasetMC->numEntries()<<endl; double XMC[Nbin],XMCerrL[Nbin],XMCerrH[Nbin],YMC[Nbin],YMCerrLo[Nbin],YMCerrHi[Nbin]; for(int i(0); i<datasetMC->numEntries();i++) { const RooArgSet &pointMC=*datasetMC->get(i); RooRealVar &etaMC=pointMC["eta"],&effMC = pointMC["efficiency"]; XMC[i]=etaMC.getVal(); XMCerrL[i]=-etaMC.getAsymErrorLo(); XMCerrH[i]=etaMC.getAsymErrorHi(); YMC[i]=effMC.getVal(); YMCerrLo[i]=-effMC.getAsymErrorLo(); YMCerrHi[i]=effMC.getAsymErrorHi(); } grMC=new TGraphAsymmErrors(Nbin,XMC,YMC,XMCerrL,XMCerrH,YMCerrLo,YMCerrHi); grMC->SetLineColor(kRed); grMC->SetMarkerColor(kRed); grMC->Draw("AP"); //grMC->Draw("psame"); myCan->SaveAs("glbToId_MCplus_eta.png"); myCan->SaveAs("glbToId_MCplus_eta.eps"); }
void sc_wptCut_P_et() { TCanvas *myCan=new TCanvas("myCan","myCan"); myCan->SetGrid(); /************************ TFile *f_RD= new TFile("TnP_Z_Trigger_RDpt.root","read"); RooDataSet *dataset = (RooDataSet*)f_RD->Get("tpTree/Track_To_TightCombRelIso_Mu15_eta2p1_pt/fit_eff"); cout<<"ntry: "<<dataset->numEntries()<<endl; double X[11],XerrL[11],XerrH[11],Y[11],YerrLo[11],YerrHi[11]; for(int i(0); i<dataset->numEntries();i++) { const RooArgSet &point=*dataset->get(i); RooRealVar &pt=point["pt"],&eff = point["efficiency"]; X[i]=pt.getVal(); XerrL[i]=-pt.getAsymErrorLo(); XerrH[i]=pt.getAsymErrorHi(); Y[i]=eff.getVal(); YerrLo[i]=-eff.getAsymErrorLo(); YerrHi[i]=eff.getAsymErrorHi(); } gr=new TGraphAsymmErrors(11,X,Y,XerrL,XerrH,YerrLo,YerrHi); gr->Draw("AP"); ***************************/ TFile *f_MC= new TFile("efficiency-mc-SCToPfElectron_et_P.root","read"); RooDataSet *datasetMC = (RooDataSet*)f_MC->Get("SuperClusterToPFElectron/SCtoWptCut_efficiency/cnt_eff"); //RooDataSet *datasetMC = (RooDataSet*)f_MC->Get("tpTree/Track_with_TightCombRelIso_to_Mu15_eta2p1_pt/fit_eff"); cout<<"ntry: "<<datasetMC->numEntries()<<endl; double XMC[binSize],XMCerrL[binSize],XMCerrH[binSize],YMC[binSize],YMCerrLo[binSize],YMCerrHi[binSize]; for(int i(0); i<datasetMC->numEntries();i++) { const RooArgSet &pointMC=*datasetMC->get(i); RooRealVar &ptMC=pointMC["probe_sc_et"],&effMC = pointMC["efficiency"]; XMC[i]=ptMC.getVal(); XMCerrL[i]=-ptMC.getAsymErrorLo(); XMCerrH[i]=ptMC.getAsymErrorHi(); YMC[i]=effMC.getVal(); YMCerrLo[i]=-effMC.getAsymErrorLo(); YMCerrHi[i]=effMC.getAsymErrorHi(); } grMC=new TGraphAsymmErrors(binSize,XMC,YMC,XMCerrL,XMCerrH,YMCerrLo,YMCerrHi); grMC->SetLineColor(kRed); grMC->SetMarkerColor(kRed); //myCan->SetLogx(); grMC->Draw("AP"); //grMC->Draw("psame"); TLine *myLine=new TLine(25,0,25,1); myLine->Draw("same"); myCan->SaveAs("sc_wptCut_P_et.png"); myCan->SaveAs("sc_wptCut_P_et.eps"); }
RooDataHist * genHistFromModelPdf(const char * name, RooAbsPdf *model, RooRealVar *var, double ScaleLumi, int range, int rebin, int seed ) { double genEvents = model->expectedEvents(*var); TRandom3 *rndm = new TRandom3(); rndm->SetSeed(seed); double nEvt = rndm->PoissonD( genEvents) ; int intEvt = ( (nEvt- (int)nEvt) >= 0.5) ? (int)nEvt +1 : int(nEvt); RooDataSet * data = model->generate(*var , intEvt ); cout<< " expected events for " << name << " = "<< genEvents << endl; cout<< " data->numEntries() for name " << name << " == " << data->numEntries()<< endl; // cout<< " nEvt from PoissonD for" << name << " == " << nEvt<< endl; //cout<< " cast of nEvt for" << name << " == " << intEvt<< endl; RooAbsData *binned_data = data->binnedClone(); TH1 * toy_hist = binned_data->createHistogram( name, *var, Binning(range/rebin ) ); for(int i = 1; i <= toy_hist->GetNbinsX(); ++i) { toy_hist->SetBinError( i, sqrt( toy_hist->GetBinContent(i)) ); if(toy_hist->GetBinContent(i) == 0.00) { cout<< " WARNING: histo " << name << " has 0 enter in bin number " << i << endl; } if(toy_hist->GetBinContent(i) < 0.1) { toy_hist->SetBinContent(i, 0.0); toy_hist->SetBinError(i, 0.0); cout<< " WARNING: setting value 0.0 to histo " << name << " for bin number " << i << endl; } } RooDataHist * toy_rooHist = new RooDataHist(name, name , RooArgList(*var), toy_hist ); return toy_rooHist; }
pair<double,double> datEvents(RooWorkspace *work, int m_hyp, int cat, bool spin=false){ vector<double> result; RooDataSet *data = (RooDataSet*)work->data(Form("data_mass_cat%d",cat)); double evs = data->numEntries(); double evsPerGev; if (!spin) evsPerGev = data->sumEntries(Form("CMS_hgg_mass>=%4.1f && CMS_hgg_mass<%4.1f",double(m_hyp)-0.5,double(m_hyp)+0.5)); else evsPerGev = data->sumEntries(Form("mass>=%4.1f && mass<%4.1f",double(m_hyp)-0.5,double(m_hyp)+0.5)); return pair<double,double>(evs,evsPerGev); }
void wspaceread_backgrounds(int channel = 1) { gSystem->AddIncludePath("-I$ROOFITSYS/include"); gROOT->ProcessLine(".L ~/tdrstyle.C"); string schannel; if (channel == 1) schannel = "4mu"; if (channel == 2) schannel = "4e"; if (channel == 3) schannel = "2mu2e"; std::cout << "schannel = " << schannel << std::endl; // 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 (generated by rf14_wspacewrite) char infile[192]; sprintf(infile,"/scratch/hep/ntran/dataFiles/HZZ4L/datasets/datasets/%s/ZZAnalysisTree_ZZTo4L_lowmass.root",schannel.c_str()); TFile *f = new TFile(infile) ; char outfile[192]; sprintf( outfile, "figs/pdf_%s_bkg_highmass.eps", schannel.c_str() ); //f->ls(); RooDataSet* set = (RooDataSet*) f->Get("data"); RooArgSet* obs = set->get() ; obs->Print(); RooRealVar* CMS_zz4l_mass = (RooRealVar*) obs->find("CMS_zz4l_mass") ; for (int i=0 ; i<set->numEntries() ; i++) { set->get(i) ; //cout << CMS_zz4l_mass->getVal() << " = " << set->weight() << endl ; } gSystem->Load("PDFs/RooqqZZPdf_cxx.so"); //gSystem->Load("PDFs/RooggZZPdf_cxx.so"); // LO contribution //RooRealVar m4l("m4l","m4l",100.,1000.); RooRealVar a1("a1","a1",224.,100.,1000.); RooRealVar a2("a2","a2",-209.,-1000.,1000.); RooRealVar a3("a3","a3",121.,20.,1000.); RooRealVar a4("a4","a4",-0.022,-10.,10.); RooRealVar b1("b1","b1",181.,100.,1000.); RooRealVar b2("b2","b2",707.,0.,1000.); RooRealVar b3("b3","b3",60.,20.,1000.); RooRealVar b4("b4","b4",0.04,-10.,10.); RooRealVar b5("b5","b5",5.,0.,1000.); RooRealVar b6("b6","b6",0.,-10.,10.); RooRealVar frac_bkg("frac_bkg","frac_bkg",0.5,0.,1.); //a1.setConstant(kTRUE); //a2.setConstant(kTRUE); //a3.setConstant(kTRUE); //a4.setConstant(kTRUE); //b1.setConstant(kTRUE); //b2.setConstant(kTRUE); //b3.setConstant(kTRUE); //b4.setConstant(kTRUE); //b5.setConstant(kTRUE); //b6.setConstant(kTRUE); RooqqZZPdf bkg_qqzz("bkg_qqzz","bkg_qqzz",*CMS_zz4l_mass,a1,a2,a3,a4,b1,b2,b3,b4,b5,b6,frac_bkg); RooFitResult *r = bkg_qqzz.fitTo( *set, SumW2Error(kTRUE) );//, Save(kTRUE), SumW2Error(kTRUE)) ; // Plot Y RooPlot* frameM4l = CMS_zz4l_mass->frame(Title("M4L"),Bins(100)) ; set->plotOn(frameM4l) ; bkg_qqzz.plotOn(frameM4l) ; TCanvas *c = new TCanvas("c","c",800,600); c->cd(); frameM4l->Draw(); /* // Retrieve workspace from file RooWorkspace* w = (RooWorkspace*) f->Get("workspace") ; w->Print(); ///* RooRealVar* CMS_zz4l_mass = w->var("CMS_zz4l_mass") ; RooAbsPdf* background_nonorm = w->pdf("background_nonorm") ; //RooAbsData* backgroundData = w->data("backgroundData") ; RooAbsData* data_bkg_red = w->data("data_bkg_red") ; RooArgSet* obs = data_bkg_red->get() ; RooRealVar* xdata = obs->find(CMS_zz4l_mass.GetName()) ; for (int i=0 ; i<data_bkg_red->numEntries() ; i++) { data_bkg_red->get(i) ; cout << xdata->getVal() << " = " << data_bkg_red->weight() << endl ; } std::cout << "nEntries = " << data_bkg_red->numEntries() << std::endl; obs->Print(); RooFitResult *r = background_nonorm->fitTo( *data_bkg_red, SumW2Error(kTRUE) );//, Save(kTRUE), SumW2Error(kTRUE)) ; // Get parameters char varName[192]; sprintf(varName, "CMS_zz%s_Nbkg", schannel.c_str()); RooRealVar* Nbkg = w->var(varName) ; sprintf(varName, "CMS_zz%s_bkgfrac", schannel.c_str()); RooRealVar* bkgfrac = w->var(varName) ; sprintf(varName, "CMS_zz%s_a1", schannel.c_str()); RooRealVar* a1 = w->var(varName) ; sprintf(varName, "CMS_zz%s_a2", schannel.c_str()); RooRealVar* a2 = w->var(varName) ; sprintf(varName, "CMS_zz%s_a3", schannel.c_str()); RooRealVar* a3 = w->var(varName) ; sprintf(varName, "CMS_zz%s_b1", schannel.c_str()); RooRealVar* b1 = w->var(varName) ; sprintf(varName, "CMS_zz%s_b2", schannel.c_str()); RooRealVar* b2 = w->var(varName) ; sprintf(varName, "CMS_zz%s_b3", schannel.c_str()); RooRealVar* b3 = w->var(varName) ; std::cout << "Nbkg: " << Nbkg->getVal() << std::endl; std::cout << "frac_bkg = " << bkgfrac->getVal() << " +/- " << bkgfrac->getError() << std::endl; std::cout << "a1 = " << a1->getVal() << " +/- " << a1->getError() << "; "; std::cout << "a2 = " << a2->getVal() << " +/- " << a2->getError() << "; "; std::cout << "a3 = " << a3->getVal() << " +/- " << a3->getError() << "; " << std::endl; std::cout << "b1 = " << b1->getVal() << " +/- " << b1->getError() << "; "; std::cout << "b2 = " << b2->getVal() << " +/- " << b2->getError() << "; "; std::cout << "b3 = " << b3->getVal() << " +/- " << b3->getError() << "; " << std::endl; // Plot data and PDF overlaid RooPlot* xframe = CMS_zz4l_mass->frame(Title("Model and data read from workspace")) ; //backgroundData->plotOn(xframe) ; data_bkg_red->plotOn(xframe) ; background_nonorm->plotOn(xframe) ; TCanvas* c = new TCanvas("c","c",800,600); c->cd(); xframe->Draw(); c->SaveAs(outfile); //*/ }
void drawPlot(string workspaceFilename, string inputFilename, string outFilename, Int_t EnergyType, Int_t CategoryBin, double minMass, double maxMass, double mean_bw, double gamma_bw, double cutoff_cb, double power_cb, const char* plotOpt, const int nbins) { TFile *workspaceFile = new TFile(workspaceFilename.c_str(), "read"); RooWorkspace* w = (RooWorkspace*)workspaceFile->Get("ZeeMassScaleAndResolutionFit"); //Create Data Set RooRealVar *mass = (RooRealVar*)w->var("mass"); // Reading everything from root tree instead citana::ZeeEventTree *zeeTree = new citana::ZeeEventTree(); zeeTree->LoadTree(inputFilename.c_str(), citana::ZeeEventTree::kCITZeeEvent); RooArgSet zMassArgSet(*mass); RooDataSet* data = new RooDataSet("data", "ntuple parameters", zMassArgSet); for (int i = 0; i < zeeTree->tree_->GetEntries(); i++) { zeeTree->tree_->GetEntry(i); //************************************************************************* //Electron Selection //************************************************************************* if (!(zeeTree->fEle1PassHZZICHEP2012 == 1 && zeeTree->fEle2PassHZZICHEP2012 == 1)) continue; //************************************************************************* //Compute electron four vector; //************************************************************************* double ele1pt = zeeTree->fEle1Pt; double ele2pt = zeeTree->fEle2Pt; if (EnergyType == 1) { ele1pt = zeeTree->fEle1EnergyRegressionWithTrkVarTwoPtBins / TMath::CosH(zeeTree->fEle1Eta); ele2pt = zeeTree->fEle2EnergyRegressionWithTrkVarTwoPtBins / TMath::CosH(zeeTree->fEle2Eta); } else if (EnergyType == 2) { ele1pt = zeeTree->fEle1EnergyRegressionWithTrkVar / TMath::CosH(zeeTree->fEle1Eta); ele2pt = zeeTree->fEle2EnergyRegressionWithTrkVar / TMath::CosH(zeeTree->fEle2Eta); } else if (EnergyType == 3) { ele1pt = zeeTree->fEle1EnergyRegressionNoTrkVarTwoPtBins / TMath::CosH(zeeTree->fEle1Eta); ele2pt = zeeTree->fEle2EnergyRegressionNoTrkVarTwoPtBins / TMath::CosH(zeeTree->fEle2Eta); } else if (EnergyType == 4) { ele1pt = zeeTree->fEle1EnergyRegressionNoTrkVar / TMath::CosH(zeeTree->fEle1Eta); ele2pt = zeeTree->fEle2EnergyRegressionNoTrkVar / TMath::CosH(zeeTree->fEle2Eta); } TLorentzVector ele1FourVector; ele1FourVector.SetPtEtaPhiM(ele1pt, zeeTree->fEle1Eta, zeeTree->fEle1Phi, ELECTRONMASS); TLorentzVector ele2FourVector; ele2FourVector.SetPtEtaPhiM(ele2pt, zeeTree->fEle2Eta, zeeTree->fEle2Phi, ELECTRONMASS); //************************************************************************* //pt and eta cuts on electron //************************************************************************* if (! (ele1pt > 7 && ele2pt > 7 && fabs( zeeTree->fEle1Eta) < 2.5 && fabs( zeeTree->fEle2Eta) < 2.5 )) continue; //************************************************************************* //pt bins and eta bins //************************************************************************* Int_t Ele1PtBin = -1; Int_t Ele1EtaBin = -1; Int_t Ele2PtBin = -1; Int_t Ele2EtaBin = -1; if (ele1pt > 10 && ele1pt < 20) Ele1PtBin = 0; else if (ele1pt < 30) Ele1PtBin = 1; else if (ele1pt < 40) Ele1PtBin = 2; else Ele1PtBin = 3; if (ele2pt > 10 && ele2pt < 20) Ele2PtBin = 0; else if (ele2pt < 30) Ele2PtBin = 1; else if (ele2pt < 40) Ele2PtBin = 2; else Ele2PtBin = 3; if (fabs(zeeTree->fEle1SCEta) < 1.0) Ele1EtaBin = 0; else if (fabs(zeeTree->fEle1SCEta) < 1.479) Ele1EtaBin = 1; else Ele1EtaBin = 2; if (fabs(zeeTree->fEle2SCEta) < 1.0) Ele2EtaBin = 0; else if (fabs(zeeTree->fEle2SCEta) < 1.479) Ele2EtaBin = 1; else Ele2EtaBin = 2; if (CategoryBin == 0) { if (!(Ele1EtaBin == 0 && Ele2EtaBin == 0)) continue; } else if (CategoryBin == 1) { if (!(Ele1EtaBin == 1 && Ele2EtaBin == 1)) continue; } else if (CategoryBin == 2) { if (!(Ele1EtaBin == 2 && Ele2EtaBin == 2)) continue; } //************************************************************************* // restrict range of mass //************************************************************************* double zMass = (ele1FourVector+ele2FourVector).M(); if (zMass < minMass || zMass > maxMass) continue; //************************************************************************* //set mass variable //************************************************************************* zMassArgSet.setRealValue("mass", zMass); data->add(zMassArgSet); } cout << "dataset size: " << data->numEntries() << endl; RooRealVar *cbBias = (RooRealVar*)w->var("#Deltam_{CB}"); RooRealVar *cbSigma = (RooRealVar*)w->var("sigma_{CB}"); RooRealVar *cbCut = (RooRealVar*)w->var("a_{CB}"); RooRealVar *cbPower = (RooRealVar*)w->var("n_{CB}"); // // Now if it's a restricted fit, fix values of cbCut and cbPower to MC values. // if (isRestricted) { // cbCut.setConstant(kTRUE); // cbPower.setConstant(kTRUE); // } // Mass model for signal electrons p.d.f. RooAddPdf *model = (RooAddPdf*)w->pdf("model"); TCanvas* c = new TCanvas("c","c", 0,0,800,600); //========================== Plotting ============================ //Create a frame RooPlot* plot = mass->frame(Range(minMass,maxMass),Bins(nbins)); // Add data and model to canvas plot->SetTitle(""); plot->GetYaxis()->SetTitleOffset(1.4); plot->GetXaxis()->SetTitle("m_{ee} (GeV/c^{2})"); data->plotOn(plot); model->plotOn(plot); // model->paramOn(plot, Format(plotOpt, AutoPrecision(1)), Parameters(RooArgSet(*cbBias, *cbSigma, *cbCut, *cbPower)), Layout(0.60,0.90,0.90)); model->paramOn(plot, Format(plotOpt, AutoPrecision(1)), Parameters(RooArgSet(*cbBias, *cbSigma, *cbCut, *cbPower)), Layout(0.12,0.38,0.60)); plot->getAttText()->SetTextSize(.025); plot->Draw(); // Print Fit Values TLatex *tex = new TLatex(); tex->SetNDC(); tex->SetTextSize(.04); tex->SetTextFont(2); tex->DrawLatex(0.195,0.775, "Run 2012A/B"); tex->Draw(); // tex->SetTextSize(0.022); // tex->DrawLatex(0.195, 0.75, "Z #rightarrow ee^{+}"); // tex->SetTextSize(0.024); // tex->DrawLatex(0.645, 0.59, Form("BW Mean = %.2f GeV/c^{2}", bwMean.getVal())); // tex->DrawLatex(0.645, 0.54, Form("BW #sigma = %.2f GeV/c^{2}", bwWidth.getVal())); c->Update(); c->SaveAs((outFilename + ".gif").c_str()); }
//____________________________________ void DoSPlot(RooWorkspace* ws){ std::cout << "Calculate sWeights" << std::endl; RooAbsPdf* model = ws->pdf("model"); RooRealVar* nsig = ws->var("nsig"); RooRealVar* nBbkg = ws->var("nBbkg"); RooRealVar* nbkg = ws->var("nbkg"); RooRealVar* nbkg2 = ws->var("nbkg2"); RooDataSet* data = (RooDataSet*) ws->data("data"); // fit the model to the data. model->fitTo(*data, Extended() ); RooMsgService::instance().setSilentMode(true); // Now we use the SPlot class to add SWeights to our data set // based on our model and our yield variables RooStats::SPlot* sData = new RooStats::SPlot("sData","An SPlot", *data, model, RooArgList(*nsig,*nBbkg,*nbkg,*nbkg2) ); // Check that our weights have the desired properties std::cout << "Check SWeights:" << std::endl; std::cout << std::endl << "Yield of sig is " << nsig->getVal() << ". From sWeights it is " << sData->GetYieldFromSWeight("nsig") << std::endl; std::cout << std::endl << "Yield of Bbkg is " << nBbkg->getVal() << ". From sWeights it is " << sData->GetYieldFromSWeight("nBbkg") << std::endl; std::cout << std::endl << "Yield of bkg is " << nbkg->getVal() << ". From sWeights it is " << sData->GetYieldFromSWeight("nbkg") << std::endl; std::cout << std::endl << "Yield of bkg2 is " << nbkg2->getVal() << ". From sWeights it is " << sData->GetYieldFromSWeight("nbkg2") << std::endl; cout << endl; cout << endl; cout << endl; float sum20=0; float sum50=0; float sum100=0; float sum200=0; float sum300=0; float sum600=0; float sum900=0; float sum1200=0; float total=0; // saving weights into a file ofstream myfile; myfile.open ("weights.txt"); // plot the weight event by event with the Sum of events values as cross-check for(Int_t i=0; i < data->numEntries(); i++) { //myfile << sData->GetSWeight(i,"nsig") << " " << sData->GetSWeight(i,"nBbkg") << " " << sData->GetSWeight(i,"nbkg") << " " << sData->GetSWeight(i,"nbkg2") << endl; //myfile << sData->GetSWeight(i,"nsig") <<endl; myfile << (unsigned int) data->get(i)->getRealValue("run") << " " << (unsigned int) data->get(i)->getRealValue("event") << " " << (float) data->get(i)->getRealValue("FourMu_Mass") << " " << sData->GetSWeight(i,"nsig") << endl; // std::cout << "nsig Weight " << sData->GetSWeight(i,"nsig") // << " nBbkg Weight " << sData->GetSWeight(i,"nBbkg") // << " nbkg Weight " << sData->GetSWeight(i,"nbkg") // << " nbkg2 Weight " << sData->GetSWeight(i,"nbkg2") // << " Total Weight " << sData->GetSumOfEventSWeight(i) // << std::endl; total+=sData->GetSWeight(i,"nsig"); if(i<20) sum20+=sData->GetSWeight(i,"nsig"); if(i<50) sum50+=sData->GetSWeight(i,"nsig"); if(i<100) sum100+=sData->GetSWeight(i,"nsig"); if(i<200) sum200+=sData->GetSWeight(i,"nsig"); if(i<300) sum300+=sData->GetSWeight(i,"nsig"); if(i<600) sum600+=sData->GetSWeight(i,"nsig"); if(i<900) sum900+=sData->GetSWeight(i,"nsig"); if(i<1200) sum1200+=sData->GetSWeight(i,"nsig"); } myfile.close(); std::cout << std::endl; std::cout<<"Sum of the sWeights is: "<<total<<std::endl; std::cout<<"Sum of the first 20 sWeights is: "<<sum20<<std::endl; std::cout<<"Sum of the first 50 sWeights is: "<<sum50<<std::endl; std::cout<<"Sum of the first 100 sWeights is: "<<sum100<<std::endl; std::cout<<"Sum of the first 200 sWeights is: "<<sum200<<std::endl; std::cout<<"Sum of the first 300 sWeights is: "<<sum300<<std::endl; std::cout<<"Sum of the first 600 sWeights is: "<<sum600<<std::endl; std::cout<<"Sum of the first 900 sWeights is: "<<sum900<<std::endl; std::cout<<"Sum of the first 1200 sWeights is: "<<sum1200<<std::endl; std::cout<<"Total # of events: "<<data->numEntries()<<std::endl; // import this new dataset with sWeights std::cout << "import new dataset with sWeights" << std::endl; ws->import(*data, Rename("dataWithSWeights")); }
// 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; }
// 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; }
int main() { TFile *tf = TFile::Open("root/MassFitResult.root"); RooWorkspace *w = (RooWorkspace*)tf->Get("w"); RooDataSet *data = (RooDataSet*)w->data("Data2012HadronTOS"); //w->loadSnapshot("bs2kstkst_mc_pdf_fit"); //RooRealVar *bs2kstkst_l = new RooRealVar("bs2kstkst_l" , "", -5., -20., 0.); //RooConstVar *bs2kstkst_zeta = new RooConstVar("bs2kstkst_zeta" , "", 0.); //RooConstVar *bs2kstkst_fb = new RooConstVar("bs2kstkst_fb" , "", 0.); //RooRealVar *bs2kstkst_sigma = new RooRealVar("bs2kstkst_sigma" , "", 15, 10, 100); //RooRealVar *bs2kstkst_mu = new RooRealVar("bs2kstkst_mu" , "", 5350, 5400 ); //RooRealVar *bs2kstkst_a = new RooRealVar("bs2kstkst_a" , "", 2.5,0,10); //RooRealVar *bs2kstkst_n = new RooRealVar("bs2kstkst_n" , "", 2.5,0,10); //RooRealVar *bs2kstkst_a2 = new RooRealVar("bs2kstkst_a2" , "", 2.5,0,10); //RooRealVar *bs2kstkst_n2 = new RooRealVar("bs2kstkst_n2" , "", 2.5,0,10); //RooIpatia2 *sig = new RooIpatia2("sig","",*w->var("B_s0_DTF_B_s0_M"), *bs2kstkst_l, *bs2kstkst_zeta, *bs2kstkst_fb, *bs2kstkst_sigma, *bs2kstkst_mu, *bs2kstkst_a, *bs2kstkst_n, *bs2kstkst_a2, *bs2kstkst_n2); //RooAbsPdf *sig = (RooAbsPdf*)w->pdf("bs2kstkst_mc_pdf"); RooIpatia2 *sig = new RooIpatia2("bs2kstkst_mc_pdf","bs2kstkst_mc_pdf",*w->var("B_s0_DTF_B_s0_M"),*w->var("bs2kstkst_l"),*w->var("bs2kstkst_zeta"),*w->var("bs2kstkst_fb"),*w->var("bs2kstkst_sigma"),*w->var("bs2kstkst_mu"),*w->var("bs2kstkst_a"),*w->var("bs2kstkst_n"),*w->var("bs2kstkst_a2"),*w->var("bs2kstkst_n2")); RooAbsPdf *bkg = (RooAbsPdf*)w->pdf("bkg_pdf_HadronTOS2012"); RooRealVar *sY = (RooRealVar*)w->var("bs2kstkst_y_HadronTOS2012"); RooRealVar *bY = (RooRealVar*)w->var("bkg_y_HadronTOS2012"); cout << sig << bkg << sY << bY << endl; RooAddPdf *pdf = new RooAddPdf("test","test", RooArgList(*sig,*bkg), RooArgList(*sY,*bY) ); pdf->fitTo(*data, Extended() ); // my sw double syVal = sY->getVal(); double byVal = bY->getVal(); // loop events int numevents = data->numEntries(); sY->setVal(0.); bY->setVal(0.); RooArgSet *pdfvars = pdf->getVariables(); vector<double> fsvals; vector<double> fbvals; for ( int ievt=0; ievt<numevents; ievt++ ) { RooStats::SetParameters(data->get(ievt), pdfvars); sY->setVal(1.); double f_s = pdf->getVal( RooArgSet(*w->var("B_s0_DTF_B_s0_M")) ); fsvals.push_back(f_s); sY->setVal(0.); bY->setVal(1.); double f_b = pdf->getVal( RooArgSet(*w->var("B_s0_DTF_B_s0_M")) ); fbvals.push_back(f_b); bY->setVal(0.); //cout << f_s << " " << f_b << endl; } TMatrixD covInv(2,2); covInv[0][0] = 0; covInv[0][1] = 0; covInv[1][0] = 0; covInv[1][1] = 0; for ( int ievt=0; ievt<numevents; ievt++ ) { data->get(ievt); double dsum=0; dsum += fsvals[ievt] * syVal; dsum += fbvals[ievt] * byVal; covInv[0][0] += fsvals[ievt]*fsvals[ievt] / (dsum*dsum); covInv[0][1] += fsvals[ievt]*fbvals[ievt] / (dsum*dsum); covInv[1][0] += fbvals[ievt]*fsvals[ievt] / (dsum*dsum); covInv[1][1] += fbvals[ievt]*fbvals[ievt] / (dsum*dsum); } covInv.Print(); cout << covInv.Determinant() << endl; TMatrixD covMatrix(TMatrixD::kInverted,covInv); covMatrix.Print(); RooStats::SPlot *sD = new RooStats::SPlot("sD","sD",*data,pdf,RooArgSet(*sY,*bY),RooArgSet(*w->var("eventNumber"))); }
void IntervalExamples() { // Time this macro TStopwatch t; t.Start(); // set RooFit random seed for reproducible results RooRandom::randomGenerator()->SetSeed(3001); // make a simple model via the workspace factory RooWorkspace* wspace = new RooWorkspace(); wspace->factory("Gaussian::normal(x[-10,10],mu[-1,1],sigma[1])"); wspace->defineSet("poi","mu"); wspace->defineSet("obs","x"); // specify components of model for statistical tools ModelConfig* modelConfig = new ModelConfig("Example G(x|mu,1)"); modelConfig->SetWorkspace(*wspace); modelConfig->SetPdf( *wspace->pdf("normal") ); modelConfig->SetParametersOfInterest( *wspace->set("poi") ); modelConfig->SetObservables( *wspace->set("obs") ); // create a toy dataset RooDataSet* data = wspace->pdf("normal")->generate(*wspace->set("obs"),100); data->Print(); // for convenience later on RooRealVar* x = wspace->var("x"); RooRealVar* mu = wspace->var("mu"); // set confidence level double confidenceLevel = 0.95; // example use profile likelihood calculator ProfileLikelihoodCalculator plc(*data, *modelConfig); plc.SetConfidenceLevel( confidenceLevel); LikelihoodInterval* plInt = plc.GetInterval(); // example use of Feldman-Cousins FeldmanCousins fc(*data, *modelConfig); fc.SetConfidenceLevel( confidenceLevel); fc.SetNBins(100); // number of points to test per parameter fc.UseAdaptiveSampling(true); // make it go faster // Here, we consider only ensembles with 100 events // The PDF could be extended and this could be removed fc.FluctuateNumDataEntries(false); // Proof // ProofConfig pc(*wspace, 4, "workers=4", kFALSE); // proof-lite //ProofConfig pc(w, 8, "localhost"); // proof cluster at "localhost" // ToyMCSampler* toymcsampler = (ToyMCSampler*) fc.GetTestStatSampler(); // toymcsampler->SetProofConfig(&pc); // enable proof PointSetInterval* interval = (PointSetInterval*) fc.GetInterval(); // example use of BayesianCalculator // now we also need to specify a prior in the ModelConfig wspace->factory("Uniform::prior(mu)"); modelConfig->SetPriorPdf(*wspace->pdf("prior")); // example usage of BayesianCalculator BayesianCalculator bc(*data, *modelConfig); bc.SetConfidenceLevel( confidenceLevel); SimpleInterval* bcInt = bc.GetInterval(); // example use of MCMCInterval MCMCCalculator mc(*data, *modelConfig); mc.SetConfidenceLevel( confidenceLevel); // special options mc.SetNumBins(200); // bins used internally for representing posterior mc.SetNumBurnInSteps(500); // first N steps to be ignored as burn-in mc.SetNumIters(100000); // how long to run chain mc.SetLeftSideTailFraction(0.5); // for central interval MCMCInterval* mcInt = mc.GetInterval(); // for this example we know the expected intervals double expectedLL = data->mean(*x) + ROOT::Math::normal_quantile( (1-confidenceLevel)/2,1) / sqrt(data->numEntries()); double expectedUL = data->mean(*x) + ROOT::Math::normal_quantile_c((1-confidenceLevel)/2,1) / sqrt(data->numEntries()) ; // Use the intervals std::cout << "expected interval is [" << expectedLL << ", " << expectedUL << "]" << endl; cout << "plc interval is [" << plInt->LowerLimit(*mu) << ", " << plInt->UpperLimit(*mu) << "]" << endl; std::cout << "fc interval is ["<< interval->LowerLimit(*mu) << " , " << interval->UpperLimit(*mu) << "]" << endl; cout << "bc interval is [" << bcInt->LowerLimit() << ", " << bcInt->UpperLimit() << "]" << endl; cout << "mc interval is [" << mcInt->LowerLimit(*mu) << ", " << mcInt->UpperLimit(*mu) << "]" << endl; mu->setVal(0); cout << "is mu=0 in the interval? " << plInt->IsInInterval(RooArgSet(*mu)) << endl; // make a reasonable style gStyle->SetCanvasColor(0); gStyle->SetCanvasBorderMode(0); gStyle->SetPadBorderMode(0); gStyle->SetPadColor(0); gStyle->SetCanvasColor(0); gStyle->SetTitleFillColor(0); gStyle->SetFillColor(0); gStyle->SetFrameFillColor(0); gStyle->SetStatColor(0); // some plots TCanvas* canvas = new TCanvas("canvas"); canvas->Divide(2,2); // plot the data canvas->cd(1); RooPlot* frame = x->frame(); data->plotOn(frame); data->statOn(frame); frame->Draw(); // plot the profile likelihood canvas->cd(2); LikelihoodIntervalPlot plot(plInt); plot.Draw(); // plot the MCMC interval canvas->cd(3); MCMCIntervalPlot* mcPlot = new MCMCIntervalPlot(*mcInt); mcPlot->SetLineColor(kGreen); mcPlot->SetLineWidth(2); mcPlot->Draw(); canvas->cd(4); RooPlot * bcPlot = bc.GetPosteriorPlot(); bcPlot->Draw(); canvas->Update(); t.Stop(); t.Print(); }
void embeddedToysVBF_1DKD(int nEvts=50, int nToys=100, sample mySample = kScalar_fa3_0){ RooRealVar* kd = new RooRealVar("psMELA","psMELA",0,1); kd->setBins(50); RooPlot* kdframe1 = kd->frame(); // 0- template TFile f1("ggH2j_KDdistribution_ps.root", "READ"); TH2F *h_KD_ps = (TH2F*)f1.Get("h_KD"); h_KD_ps->SetName("h_KD_ps"); RooDataHist rdh_KD_ps("rdh_KD_ps","rdh_KD_ps",RooArgList(*kd),h_KD_ps); RooHistPdf pdf_KD_ps("pdf_KD_ps","pdf_KD_ps",RooArgList(*kd),rdh_KD_ps); // 0+ template TFile f2("ggH2j_KDdistribution_sm.root", "READ"); TH2F *h_KD_sm = (TH2F*)f2.Get("h_KD"); h_KD_sm->SetName("h_KD_sm"); RooDataHist rdh_KD_sm("rdh_KD_sm","rdh_KD_sm",RooArgList(*kd),h_KD_sm); RooHistPdf pdf_KD_sm("pdf_KD_sm","pdf_KD_sm",RooArgList(*kd),rdh_KD_sm); RooRealVar rrv_fa3("fa3","fa3",0.5,0.,1.); //free parameter of the model RooAddPdf model("model","ps+sm",pdf_KD_ps,pdf_KD_sm,rrv_fa3); rrv_fa3.setConstant(kFALSE); TCanvas* c = new TCanvas("modelPlot","modelPlot",400,400); rdh_KD_ps.plotOn(kdframe1,LineColor(kBlack)); pdf_KD_ps.plotOn(kdframe1,LineColor(kBlack)); rdh_KD_sm.plotOn(kdframe1,LineColor(kBlue)); pdf_KD_sm.plotOn(kdframe1,LineColor(kBlue)); model.plotOn(kdframe1,LineColor(kRed)); kdframe1->Draw(); c->SaveAs("model1DPlot.png"); c->SaveAs("model1DPlot.eps"); double fa3Val=-99; if (mySample == kScalar_fa3_0) fa3Val=0.; else if (mySample == kScalar_fa3_1) fa3Val=1; else{ cout<<"fa3Val not correct!"<<endl; return 0; } TCanvas* c = new TCanvas("modelPlot","modelPlot",400,400); rdh_KD_ps.plotOn(kdframe1,LineColor(kBlack)); pdf_KD_ps.plotOn(kdframe1,LineColor(kBlack)); rdh_KD_sm.plotOn(kdframe1,LineColor(kBlue)); pdf_KD_sm.plotOn(kdframe1,LineColor(kBlue)); model.plotOn(kdframe1,LineColor(kRed)); kdframe1->Draw(); TChain* myChain = new TChain("newTree"); myChain->Add(inputFileNames[mySample]); if(!myChain || myChain->GetEntries()<=0) { cout<<"error in the tree"<<endl; return 0; } RooDataSet* data = new RooDataSet("data","data",myChain,RooArgSet(*kd),""); cout << "Number of events in data: " << data->numEntries() << endl; // initialize tree to save toys to TTree* results = new TTree("results","toy results"); double fa3,fa3Error, fa3Pull; double fa2,fa2Error, fa2Pull; double phia2, phia2Error, phia2Pull; double phia3, phia3Error, phia3Pull; results->Branch("fa3",&fa3,"fa3/D"); results->Branch("fa3Error",&fa3Error,"fa3Error/D"); results->Branch("fa3Pull",&fa3Pull,"fa3Pull/D"); //--------------------------------- RooDataSet* toyData; int embedTracker=0; RooArgSet *tempEvent; RooFitResult *toyfitresults; RooRealVar *r_fa3; for(int i = 0 ; i<nToys ; i++){ cout <<i<<"<-----------------------------"<<endl; //if(toyData) delete toyData; toyData = new RooDataSet("toyData","toyData",RooArgSet(*kd)); if(nEvts+embedTracker > data->sumEntries()){ cout << "Playground::generate() - ERROR!!! Playground::data does not have enough events to fill toy!!!! bye :) " << endl; toyData = NULL; abort(); return 0; } for(int iEvent=0; iEvent<nEvts; iEvent++){ if(iEvent==1) cout << "generating event: " << iEvent << " embedTracker: " << embedTracker << endl; tempEvent = (RooArgSet*) data->get(embedTracker); toyData->add(*tempEvent); embedTracker++; } toyfitresults =model.fitTo(*toyData,Save()); cout<<toyfitresults<<endl; r_fa3 = (RooRealVar *) toyfitresults->floatParsFinal().find("fa3"); fa3 = r_fa3->getVal(); fa3Error = r_fa3->getError(); fa3Pull = (r_fa3->getVal() - fa3Val) / r_fa3->getError(); // fill TTree results->Fill(); //model.clear(); } char nEvtsString[100]; sprintf(nEvtsString,"_%iEvts",nEvts); // write tree to output file (ouputFileName set at top) TFile *outputFile = new TFile("embeddedToysVBF_fa3Corr_"+sampleName[mySample]+nEvtsString+".root","RECREATE"); results->Write(); outputFile->Close(); }
void track_pt(const int charge) { if (charge==1) char ch[20] = "plus"; else if (charge==-1) char ch[20] = "minus"; ofstream txtfile; char txtfname[100]; char histfname[100]; sprintf(txtfname,"pt_%s.txt",ch); sprintf(histfname,"pt_%s.png",ch); txtfile.open(txtfname); txtfile << fixed << setprecision(4); TCanvas *myCan=new TCanvas("myCan","myCan",800,600); gStyle->SetLineWidth(2.); gStyle->SetLabelSize(0.04,"xy"); gStyle->SetTitleSize(0.05,"xy"); gStyle->SetTitleOffset(1.1,"x"); gStyle->SetTitleOffset(1.2,"y"); gStyle->SetPadTopMargin(0.1); gStyle->SetPadRightMargin(0.1); gStyle->SetPadBottomMargin(0.16); gStyle->SetPadLeftMargin(0.12); myCan->SetGrid(); TLegend* Lgd = new TLegend(.8, .25,.9,.35); if (charge==1){ TFile *f_MC= new TFile("TnP_Tracking_dr030e030_MCptplus.root","read"); TFile *f_RD= new TFile("TnP_Tracking_dr030e030_RDptplus.root","read"); }else if (charge==-1){ TFile *f_MC= new TFile("TnP_Tracking_dr030e030_MCptminus.root","read"); TFile *f_RD= new TFile("TnP_Tracking_dr030e030_RDptminus.root","read"); } line = new TLine(15,1,80,1); line->SetLineStyle(2); line->SetLineWidth(3); TPaveText *title = new TPaveText(.1,1,.95,.95,"NDC"); title->SetFillStyle(0); title->SetBorderSize(0); title->SetTextSize(0.04); title->AddText("CMS Preliminary, 18.9 pb^{-1} at #sqrt{s}=8 TeV"); RooDataSet *datasetMC = (RooDataSet*)f_MC->Get("tpTreeSta/eff_pt_dr030e030/fit_eff"); cout<<"ntry: "<<datasetMC->numEntries()<<endl; double XMC[Nbin],XMCerrL[Nbin],XMCerrH[Nbin],YMC[Nbin],YMCerrLo[Nbin],YMCerrHi[Nbin],ErrMC[Nbin]; for(int i(0); i<datasetMC->numEntries();i++) { const RooArgSet &pointMC=*datasetMC->get(i); RooRealVar &ptMC=pointMC["pt"],&effMC = pointMC["efficiency"]; XMC[i]=ptMC.getVal(); XMCerrL[i]=-ptMC.getAsymErrorLo(); XMCerrH[i]=ptMC.getAsymErrorHi(); YMC[i]=effMC.getVal(); YMCerrLo[i]=-effMC.getAsymErrorLo(); YMCerrHi[i]=effMC.getAsymErrorHi(); ErrMC[i]=TMath::Max(YMCerrLo[i],YMCerrHi[i]); } grMC=new TGraphAsymmErrors(Nbin,XMC,YMC,XMCerrL,XMCerrH,YMCerrLo,YMCerrHi); grMC->SetLineColor(kRed); grMC->SetMarkerColor(kRed); grMC->SetMarkerStyle(21); grMC->SetMinimum(0.7); grMC->SetMaximum(1.11); grMC->GetXaxis()->SetNdivisions(505); grMC->GetXaxis()->SetTitle("Muon p_{T} [GeV/c]"); grMC->GetYaxis()->SetTitle("Tracking Efficiency"); grMC->Draw("AP"); RooDataSet *datasetRD = (RooDataSet*)f_RD->Get("tpTreeSta/eff_pt_dr030e030/fit_eff"); double XRD[Nbin],XRDerrL[Nbin],XRDerrH[Nbin],YRD[Nbin],YRDerrLo[Nbin],YRDerrHi[Nbin],ErrRD[Nbin]; for(int i(0); i<datasetRD->numEntries();i++) { const RooArgSet &pointRD=*datasetRD->get(i); RooRealVar &ptRD=pointRD["pt"],&effRD = pointRD["efficiency"]; XRD[i]=ptRD.getVal(); XRDerrL[i]=-ptRD.getAsymErrorLo(); XRDerrH[i]=ptRD.getAsymErrorHi(); YRD[i]=effRD.getVal(); YRDerrLo[i]=-effRD.getAsymErrorLo(); YRDerrHi[i]=effRD.getAsymErrorHi(); ErrRD[i]=TMath::Max(YRDerrLo[i],YRDerrHi[i]); } double SF[Nbin],SFerr[Nbin],SFerrL[Nbin],SFerrH[Nbin]; for(int i(0); i<datasetRD->numEntries();i++) { SF[i]=YRD[i]/YMC[i]; SFerrL[i]=YRD[i]*sqrt(YMCerrLo[i]*YMCerrLo[i]/(YMC[i]*YMC[i])+YRDerrLo[i]*YRDerrLo[i]/(YRD[i]*YRD[i]))/YMC[i]; SFerrH[i]=YRD[i]*sqrt(YMCerrHi[i]*YMCerrHi[i]/(YMC[i]*YMC[i])+YRDerrHi[i]*YRDerrHi[i]/(YRD[i]*YRD[i]))/YMC[i]; SFerr[i]=TMath::Max(SFerrL[i],SFerrH[i]); txtfile << i << "\t" << YMC[i] << "\t" << ErrMC[i] << "\t" << YRD[i] << "\t" << ErrRD[i] << "\t" << SF[i] << "\t" << SFerr[i] << endl; } grRD=new TGraphAsymmErrors(Nbin,XRD,YRD,XRDerrL,XRDerrH,YRDerrLo,YRDerrHi); grRD->SetLineColor(kBlack); grRD->SetMarkerColor(kBlack); grSF=new TGraphAsymmErrors(Nbin,XRD,SF,0,0,SFerrL,SFerrH); grSF->SetLineColor(8); grSF->SetMarkerStyle(25); grSF->SetMarkerColor(8); Lgd->AddEntry(grMC,"MC","pl"); Lgd->AddEntry(grRD,"RD","pl"); Lgd->SetFillStyle(0); Lgd->Draw(); grRD->Draw("PSAME"); grSF->Draw("PSAME"); line->Draw(); title->Draw(); myCan->SaveAs(histfname); txtfile.close(); }
void glbToId_eta() { ofstream txtfile; char txtfname[100]; char histfname[100]; sprintf(txtfname,"eta_plus.txt"); sprintf(histfname,"eta_plus.png"); //sprintf(txtfname,"eta_minus.txt"); //sprintf(histfname,"eta_minus.png"); txtfile.open(txtfname); txtfile << fixed << setprecision(4); TCanvas *myCan=new TCanvas("myCan","myCan",800,600); gStyle->SetLineWidth(2.); gStyle->SetLabelSize(0.04,"xy"); gStyle->SetTitleSize(0.05,"xy"); gStyle->SetTitleOffset(1.1,"x"); gStyle->SetTitleOffset(1.2,"y"); gStyle->SetPadTopMargin(0.1); gStyle->SetPadRightMargin(0.1); gStyle->SetPadBottomMargin(0.16); gStyle->SetPadLeftMargin(0.12); myCan->SetGrid(); TLegend* Lgd = new TLegend(.8, .25,.9,.35); TFile *f_MCndof2= new TFile("TnP_GlbToID_MCetaplus_Wpteta_eta.root","read"); TFile *f_MCndof4= new TFile("TnP_GlbToID_MCetaplus_ndof4_Wpteta_eta.root","read"); //TFile *f_MCndof2= new TFile("TnP_GlbToID_MCetaminus_Wpteta_eta.root","read"); //TFile *f_MCndof4= new TFile("TnP_GlbToID_MCetaminus_ndof4_Wpteta_eta.root","read"); RooDataSet *datasetMC = (RooDataSet*)f_MCndof2->Get("tpTree/Wpteta_eta/fit_eff"); cout<<"ntry: "<<datasetMC->numEntries()<<endl; double XMC[Nbin],XMCerrL[Nbin],XMCerrH[Nbin],YMC[Nbin],YMCerrLo[Nbin],YMCerrHi[Nbin],ErrMC[Nbin]; for(int i(0); i<datasetMC->numEntries();i++) { const RooArgSet &pointMC=*datasetMC->get(i); RooRealVar &etaMC=pointMC["eta"],&effMC = pointMC["efficiency"]; XMC[i]=etaMC.getVal(); XMCerrL[i]=-etaMC.getAsymErrorLo(); XMCerrH[i]=etaMC.getAsymErrorHi(); YMC[i]=effMC.getVal(); YMCerrLo[i]=-effMC.getAsymErrorLo(); YMCerrHi[i]=effMC.getAsymErrorHi(); ErrMC[i]=TMath::Max(YMCerrLo[i],YMCerrHi[i]); } grMC=new TGraphAsymmErrors(Nbin,XMC,YMC,XMCerrL,XMCerrH,YMCerrLo,YMCerrHi); grMC->SetLineColor(kRed); grMC->SetMarkerColor(kRed); grMC->SetMinimum(0.5); grMC->SetMaximum(1.1); grMC->GetXaxis()->SetNdivisions(505); grMC->GetXaxis()->SetTitle("Muon #eta"); grMC->GetYaxis()->SetTitle("ID+ISO Efficiency"); grMC->Draw("AP"); RooDataSet *datasetRD = (RooDataSet*)f_MCndof4->Get("tpTree/Wpteta_eta/fit_eff"); double XRD[Nbin],XRDerrL[Nbin],XRDerrH[Nbin],YRD[Nbin],YRDerrLo[Nbin],YRDerrHi[Nbin],ErrRD[Nbin]; for(int i(0); i<datasetRD->numEntries();i++) { const RooArgSet &pointRD=*datasetRD->get(i); RooRealVar &etaRD=pointRD["eta"],&effRD = pointRD["efficiency"]; XRD[i]=etaRD.getVal(); XRDerrL[i]=-etaRD.getAsymErrorLo(); XRDerrH[i]=etaRD.getAsymErrorHi(); YRD[i]=effRD.getVal(); YRDerrLo[i]=-effRD.getAsymErrorLo(); YRDerrHi[i]=effRD.getAsymErrorHi(); ErrRD[i]=TMath::Max(YRDerrLo[i],YRDerrHi[i]); } txtfile << "Bins \t MC ndof>2\t\t\t MC ndof>4 \t\t\t Scale Factor ndof4/ndof2 " << endl; for(int i(0); i<datasetRD->numEntries();i++) { txtfile << i << "\t" << YMC[i] << "+/-" << ErrMC[i] << "\t\t" << YRD[i] << "+/-" << ErrRD[i] << "\t\t" << YRD[i]/YMC[i] << "+/-" << YRD[i]*sqrt(ErrMC[i]*ErrMC[i]/(YMC[i]*YMC[i])+ErrRD[i]*ErrRD[i]/(YRD[i]*YRD[i]))/YMC[i] << endl; } grRD=new TGraphAsymmErrors(Nbin,XRD,YRD,XRDerrL,XRDerrH,YRDerrLo,YRDerrHi); grRD->SetLineColor(kBlack); grRD->SetMarkerColor(kBlack); Lgd->AddEntry(grMC,"MC ndof>2","pl"); Lgd->AddEntry(grRD,"MC ndof>4","pl"); Lgd->SetFillStyle(0); Lgd->Draw(); grRD->Draw("PSAME"); myCan->SaveAs(histfname); txtfile.close(); }
int main(){ BaBarStyle p; p.SetBaBarStyle(); //gROOT->SetStyle("Plain"); Bool_t doNorm = kTRUE; Bool_t doComparison = kFALSE; Bool_t doFract = kFALSE; Bool_t doFit = kFALSE; Bool_t doPlots = kFALSE; //define DalitzSpace for generation EvtPDL pdl; pdl.readPDT("evt.pdl"); EvtDecayMode mode("D0 -> K- pi+ pi0"); EvtDalitzPlot dalitzSpace(mode); RooRealVar m2Kpi_d0mass("m2Kpi_d0mass","m2Kpi_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AB),dalitzSpace.qAbsMax(EvtCyclic3::AB)); RooRealVar m2Kpi0_d0mass("m2Kpi0_d0mass","m2Kpi0_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AC),dalitzSpace.qAbsMax(EvtCyclic3::AC)); RooRealVar m2pipi0_d0mass("m2pipi0_d0mass","m2pipi0_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::BC),dalitzSpace.qAbsMax(EvtCyclic3::BC)); RooCategory D0flav("D0flav","D0flav"); D0flav.defineType("D0",-1); D0flav.defineType("antiD0",1); //this is just to plot the m23 pdf Float_t total = pow(dalitzSpace.bigM(),2) + pow(dalitzSpace.mA(),2) + pow(dalitzSpace.mB(),2) + pow(dalitzSpace.mC(),2); RooRealVar totalm("totalm","totalm",total); RooFormulaVar mass13a("mass13a","@0-@1-@2",RooArgSet(totalm,m2Kpi_d0mass,m2pipi0_d0mass)); cout << "read the dataset" << endl; TFile hello("DataSet_out_tmp.root"); gROOT->cd(); RooDataSet *data = (RooDataSet*)hello.Get("fulldata"); RooDataSet *data_1 = (RooDataSet*)data->reduce("D0flav == 1 && isWS == 0 && d0LifetimeErr < 0.5 && d0Lifetime > -2. && d0Lifetime < 4."); RooDataSet *finaldata = (RooDataSet*)data_1->reduce("deltaMass > 0.1449 && deltaMass < 0.1459 && d0Mass > 1.8495 && d0Mass < 1.8795"); RooDataSet *leftdata = (RooDataSet*)(RooDataSet*)data_1->reduce("d0Mass > 1.74 && d0Mass < 1.79"); RooDataSet *rightdata = (RooDataSet*)data_1->reduce("d0Mass > 1.94 && d0Mass < 1.99"); //here we set the weights for the dataset finaldata->setWeightVar(0); leftdata->setWeightVar(0); rightdata->setWeightVar(0); //if you want to have a little dataset to test, uncomment next line and rename finaldata above //RooDataSet *finaldata = finaldata_1->reduce(EventRange(1,1000)); cout << "*************************************************************" << endl; cout << "The final data entry " << finaldata->numEntries() << endl; cout << "*************************************************************" << endl; //Construct signal pdf string dirname = "configmaps/effmapping_RS_CP/"; RooKpipi0pdf *D0pdf = new RooKpipi0pdf("D0pdf","D0pdf",m2Kpi_d0mass,m2Kpi0_d0mass,&dalitzSpace,dirname,1); RooKpipi0pdf *D0pdf23 = new RooKpipi0pdf("D0pdf23","D0pdf23",m2Kpi_d0mass,mass13a,&dalitzSpace,dirname,1); if(doNorm) D0pdf->getManager()->calNorm(); //When we plot the 1D projection, need to calculate the 1D integral //set the precision here //cout << "config integrator " << endl; RooNumIntConfig *cfg = RooAbsReal::defaultIntegratorConfig(); cfg->setEpsAbs(1E-3); cfg->setEpsRel(1E-3); cfg->method1D().setLabel("RooSegmentedIntegrator1D"); //cfg.getConfigSection("RooSegmentedIntegrator1D").setRealValue("numSeg",3); //cfg->method1D()->Print("v"); D0pdf->setIntegratorConfig(*cfg); D0pdf23->setIntegratorConfig(*cfg); cout << "about to init" << endl; m2Kpi_d0mass.setBins(150); m2Kpi0_d0mass.setBins(150); m2pipi0_d0mass.setBins(150); //background description //RooBkg combdalitz("combdalitz","combdalitz",m2Kpi_d0mass,m2Kpi0_d0mass,&dalitzSpace); //RooBkg combdalitz23("combdalitz23","combdalitz23",m2Kpi_d0mass,mass13a,&dalitzSpace); RooRealVar Nsig("Nsig","Nsig", 653962. + 2218.); RooRealVar Nbkg("Nbkg","Nbkg", 2255. + 551.); RooDataHist* dbdalitz = new RooDataHist("dbdalitz","dbdalitz",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*finaldata); RooDataHist* dbdalitz23 = new RooDataHist("dbdalitz23","dbdalitz23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*finaldata); //////////////////////////////////////// //background parametrization using sidebands histograms //////////////////////////////////////// TH2F *lefth = m2Kpi_d0mass.createHistogram("lefth",m2Kpi0_d0mass); leftdata->fillHistogram(lefth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass)); TH2F *righth = m2Kpi_d0mass.createHistogram("righth",m2Kpi0_d0mass); rightdata->fillHistogram(righth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass)); TH2F *lefth23 = m2Kpi_d0mass.createHistogram("lefth23",m2pipi0_d0mass); leftdata->fillHistogram(lefth23,RooArgList(m2Kpi_d0mass,m2pipi0_d0mass)); TH2F *righth23 = m2Kpi_d0mass.createHistogram("righth23",m2pipi0_d0mass); rightdata->fillHistogram(righth23,RooArgList(m2Kpi_d0mass,m2pipi0_d0mass)); righth->Scale(lefth->Integral()/righth->Integral()); lefth->Sumw2(); righth->Sumw2(); righth23->Scale(lefth23->Integral()/righth23->Integral()); lefth23->Sumw2(); righth23->Sumw2(); RooDataHist *lefthist = new RooDataHist("lefthist","lefthist",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),lefth); RooDataHist *righthist = new RooDataHist("righthist","righthist",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),righth); RooDataHist *lefthist23 = new RooDataHist("lefthist23","lefthist23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),lefth23); RooDataHist *righthist23 = new RooDataHist("righthist23","righthist23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),righth23); RooHistPdf leftpdf("leftpdf","leftpdf",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*lefthist,4); RooHistPdf rightpdf("rightpdf","rightpdf",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*righthist,4); RooHistPdf leftpdf23("leftpdf23","leftpdf23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*lefthist23,4); RooHistPdf rightpdf23("rightpdf23","rightpdf23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*righthist23,4); RooRealVar fcomb("fcomb","fcomb",0.738); RooAddPdf combdalitz("combdalitz","combdalitz",RooArgList(leftpdf,rightpdf),RooArgList(fcomb)); RooAddPdf combdalitz23("combdalitz23","combdalitz23",RooArgList(leftpdf23,rightpdf23),RooArgList(fcomb)); /////////////////////////////////////// RooAddPdf totpdf("totpdf","totpdf",RooArgList(*D0pdf,combdalitz),RooArgList(Nsig,Nbkg)); RooAddPdf totpdf23("totpdf23","totpdf23",RooArgList(*D0pdf23,combdalitz23),RooArgList(Nsig,Nbkg)); if(doFit){ // Start Minuit session on Chi2 RooChi2Var chi2("chi2","chi2",totpdf,*dbdalitz); RooMinuit m2(chi2); m2.migrad(); m2.hesse(); RooFitResult* fitRes = m2.save(); fitRes->Print("v"); RooArgSet results(fitRes->floatParsFinal()); RooArgSet conresults(fitRes->constPars()); results.add(conresults); results.writeToFile("fit_isobar_RS.txt"); //save the stupid result TFile f("fit_RSDalitz_result.root","RECREATE"); fitRes->Write(); f.Close(); } if(doFract) { cout << "Calculating fit fractions" << endl; TFile f("fit_RSDalitz_result.root"); RooFitResult* fitRes = (RooFitResult*)f.Get("chi2"); //now calculate the fit fractions const Int_t nRes = D0pdf->getManager()->getnRes(); //recalculate the normalization if necessary D0pdf->getManager()->calNorm(); EvtComplex normarray[nRes][nRes]; const Int_t myRes = 12; TH1F fitty[myRes]; //read the integral value from the cache file. //In this way we don't need to compute the normalization everytime during MIGRAD char int_name[50]; D0pdf->getManager()->getFileName(int_name); ifstream f1; f1.open(int_name); if (!f1){ cout << "Error opening file " << endl; assert(0); } Double_t re=0.,im=0.; //Read in the cache file and store back to array for(Int_t j=0;j<nRes;j++) { char thname[100]; sprintf(thname,"thname_%d",j); if(j < myRes) fitty[j] = TH1F(thname,thname,30,0.,1.); for(Int_t k=0;k<nRes;k++){ f1 >> re >> im; normarray[j][k] = EvtComplex(re,im); } } EvtComplex mynorm[myRes][myRes]; Int_t m = 0, l = 0; for(Int_t i=0;i<myRes;i++){ for(Int_t j=0;j<myRes;j++){ if(i==0) l = 7; else if(i==1) l = 6; else if(i==2) l = 11; else if(i==3) l = 4; else if(i==4) l = 5; else if(i==5) l = 3; else if(i==6) l = 9; else if(i==7) l = 10; else if(i==8) l = 12; else if(i==9) l = 8; else if(i==10) l = 2; else if(i==11) l = 0; if(j==0) m = 7; else if(j==1) m = 6; else if(j==2) m = 11; else if(j==3) m = 4; else if(j==4) m = 5; else if(j==5) m = 3; else if(j==6) m = 9; else if(j==7) m = 10; else if(j==8) m = 12; else if(j==9) m = 8; else if(j==10) m = 2; else if(j==11) m = 0; mynorm[i][j] = normarray[l][m]; } } //do 100 experiments and extract parameters using covariance matrix for(Int_t l=0;l<300;l++){ RooArgList listpar = fitRes->randomizePars(); if(l==0) listpar.Print(); Double_t mynormD0 = 0.; EvtComplex coeff_i(0.,0.), coeff_j(0.,0.); for(Int_t i=0;i<2*myRes;i++){ for(Int_t j=0;j<2*myRes;j++){ if(i==(2*myRes - 2)) coeff_i = EvtComplex(1.,0.); else coeff_i = EvtComplex(((RooAbsReal*)listpar.at(i))->getVal()*cos(((RooAbsReal*)listpar.at(i+1))->getVal()), ((RooAbsReal*)listpar.at(i))->getVal()*sin(((RooAbsReal*)listpar.at(i+1))->getVal())); if(j==(2*myRes - 2)) coeff_j = EvtComplex(1.,0.); else coeff_j = EvtComplex(((RooAbsReal*)listpar.at(j))->getVal()*cos(((RooAbsReal*)listpar.at(j+1))->getVal()), ((RooAbsReal*)listpar.at(j))->getVal()*sin(((RooAbsReal*)listpar.at(j+1))->getVal())); mynormD0 += real(coeff_i*conj(coeff_j)*(mynorm[i/2][j/2])); j++; } i++; } //now calculate the fit fractions for(Int_t i=0;i<2*myRes;i++){ Double_t fitfrac = 0.; if(i==(2*myRes - 2)) fitfrac = abs(mynorm[i/2][i/2])/mynormD0; else fitfrac = abs2( ((RooAbsReal*)listpar.at(i))->getVal())*abs(mynorm[i/2][i/2])/mynormD0; fitty[i/2].Fill(fitfrac); i++; } }// nexperiments Double_t tot_frac = 0.; for(Int_t i=0;i<myRes;i++){ tot_frac += fitty[i].GetMean(); cout << "Resonance " << i << ": fit fraction = " << fitty[i].GetMean() << " +/- " << fitty[i].GetRMS() << endl; } cout << "Total fit fraction = " << tot_frac << endl; cout << "///////////////////////////" << endl; } if(doPlots){ //Make the plots // REMEBER: if you want roofit to consider the reweighted errors, you must put DataError(RooAbsData::SumW2)) //****************************************************** RooPlot* xframe = m2Kpi_d0mass.frame(); dbdalitz->plotOn(xframe,MarkerSize(0.1),DrawOption("z")); totpdf.plotOn(xframe); xframe->getAttLine()->SetLineWidth(1); xframe->getAttLine()->SetLineStyle(1); xframe->SetTitle(""); xframe->GetXaxis()->SetTitle("s_{12} [GeV^{2}/c^{4}]"); xframe->GetYaxis()->SetTitle("Events/4 MeV^{2}/c^{4}"); Double_t chi2Kpi = xframe->chiSquare(); RooPlot* yframe = m2Kpi0_d0mass.frame(); dbdalitz->plotOn(yframe,MarkerSize(0.1),DrawOption("z")); totpdf.plotOn(yframe); yframe->getAttLine()->SetLineWidth(1); yframe->getAttLine()->SetLineStyle(1); yframe->SetTitle(""); yframe->GetXaxis()->SetTitle("s_{13} [GeV^{2}/c^{4}]"); yframe->GetYaxis()->SetTitle("Events/5 MeV^{2}/c^{4}"); Double_t chi2Kpi0 = yframe->chiSquare(); /* RooPlot* zframe = m2pipi0_d0mass.frame(0.,2.3); dbdalitz23->plotOn(zframe,MarkerSize(0.1),DrawOption("z")); totpdf23.plotOn(zframe); zframe->getAttLine()->SetLineWidth(1); zframe->getAttLine()->SetLineStyle(1); zframe->SetTitle(""); zframe->GetXaxis()->SetTitle("m^{2}_{#pi^{+}#pi^{0}}"); Double_t chi2pipi0 = zframe->chiSquare(); cout << "Chi2 for Kpi = " << chi2Kpi << endl; cout << "Chi2 for Kpi0 = " << chi2Kpi0 << endl; cout << "Chi2 for pipi0 = " << chi2pipi0 << endl; RooPlot* pullFramem12 = m2Kpi_d0mass.frame() ; pullFramem12->SetTitle(""); pullFramem12->GetXaxis()->SetTitle(""); pullFramem12->addPlotable(xframe->pullHist()) ; pullFramem12->SetMaximum(5.); pullFramem12->SetMinimum(-5.); RooPlot* pullFramem13 = m2Kpi0_d0mass.frame() ; pullFramem13->SetTitle(""); pullFramem13->GetXaxis()->SetTitle(""); pullFramem13->addPlotable(yframe->pullHist()) ; pullFramem13->SetMaximum(5.); pullFramem13->SetMinimum(-5.); RooPlot* pullFramem23 = m2pipi0_d0mass.frame() ; pullFramem23->SetTitle(""); pullFramem23->GetXaxis()->SetTitle(""); pullFramem23->addPlotable(zframe->pullHist()) ; pullFramem23->SetMaximum(5.); pullFramem23->SetMinimum(-5.); TCanvas *c2 = new TCanvas("c2","residuals",1200,200); c2->Divide(3,1); c2->cd(1);pullFramem12->Draw(); c2->cd(2);pullFramem13->Draw(); c2->cd(3);pullFramem23->Draw(); c2->SaveAs("RSresiduals.eps"); */ totpdf.plotOn(xframe,Project(m2Kpi0_d0mass),Components(RooArgSet(combdalitz)),DrawOption("F"),FillColor(kRed)); totpdf.plotOn(yframe,Project(m2Kpi_d0mass),Components(RooArgSet(combdalitz)),DrawOption("F"),FillColor(kRed)); //totpdf23.plotOn(zframe,Project(m2Kpi_d0mass),Components(RooArgSet(combdalitz23)),DrawOption("F"),FillColor(kRed)); TPaveText *box_m12 = new TPaveText(2.5,2.5,2.7,2.7,""); box_m12->AddText("(b)"); box_m12->SetFillColor(10); TPaveText *box_m13 = new TPaveText(2.5,2.5,2.7,2.7,""); box_m13->AddText("(c)"); box_m13->SetFillColor(10); TCanvas c1("c1","c1",600,600); c1.cd(); xframe->Draw();box_m12->Draw("SAME"); c1.SaveAs("RSfit_m2Kpi.eps"); TCanvas c2("c2","c2",600,600); c2.cd(); yframe->Draw();box_m13->Draw("SAME"); c2.SaveAs("RSfit_m2Kpi0.eps"); /* TCanvas *c1 = new TCanvas("c1","allevents",1200,400); c1->Divide(3,1); c1->cd(1);xframe->Draw(); //p.SetBaBarLabel(-1,-1,-1,"preliminary"); c1->cd(2);yframe->Draw(); //p.SetBaBarLabel(-1,-1,-1,"preliminary"); c1->cd(3);zframe->Draw(); //p.SetBaBarLabel(-1,-1,-1,"preliminary"); c1->SaveAs("RSsigfit.eps"); */ } if(doComparison){ RooDataSet *littledata = (RooDataSet*)finaldata->reduce(EventRange(1,70000)); RooArgSet VarList1(m2Kpi_d0mass,m2Kpi0_d0mass); Int_t num_entries = littledata->numEntries(); RooDataSet* genpdf = D0pdf->generate(VarList1,num_entries); Int_t nbinx = 20; Int_t nbiny = 20; m2Kpi_d0mass.setBins(nbinx); m2Kpi0_d0mass.setBins(nbiny); TH2F* pdfhist = new TH2F("pdfhist","pdfhist",nbinx,0.39,3.,nbiny,0.39,3.); TH2F* datahist = new TH2F("datahist","datahist",nbinx,0.39,3.,nbiny,0.39,3.); pdfhist = genpdf->createHistogram(m2Kpi_d0mass,m2Kpi0_d0mass); datahist = finaldata->createHistogram(m2Kpi_d0mass,m2Kpi0_d0mass); pdfhist->GetXaxis()->SetTitle("m_{K#pi}^{2}"); pdfhist->GetYaxis()->SetTitle("m_{K#pi^{0}}^{2}"); pdfhist->Scale(datahist->Integral()/pdfhist->Integral()); pdfhist->Add(datahist,-1.); TCanvas c2; c2.cd();pdfhist->Draw("LEGO2Z"); c2.SaveAs("RSsigdiff.eps"); TFile ftmp("prova.root","RECREATE"); ftmp.cd();pdfhist->Write(); ftmp.Close(); } return 0; }//end of the macro
int main(int argc, char *argv[]){ OptionParser(argc,argv); RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR); RooMsgService::instance().setSilentMode(true); system(Form("mkdir -p %s",outdir_.c_str())); vector<string> procs; split(infilenames_,infilenamesStr_,boost::is_any_of(",")); TPython::Exec("import os,imp,re"); for (unsigned int i =0 ; i<infilenames_.size() ; i++){ TFile *infile = TFile::Open(infilenames_[i].c_str()); string outname =(string) TPython::Eval(Form("'%s'.split(\"/\")[-1].replace('root','_reduced.root')",infilenames_[i].c_str())); TFile *outfile = TFile::Open(outname.c_str(),"RECREATE") ; TDirectory* saveDir = outfile->mkdir("tagsDumper"); saveDir->cd(); RooWorkspace *inWS = (RooWorkspace*) infile->Get("tagsDumper/cms_hgg_13TeV"); RooRealVar *intLumi = (RooRealVar*)inWS->var("IntLumi"); RooWorkspace *outWS = new RooWorkspace("cms_hgg_13TeV"); outWS->import(*intLumi); std::list<RooAbsData*> data = (inWS->allData()) ; std::cout <<" [INFO] Reading WS dataset contents: "<< std::endl; for (std::list<RooAbsData*>::const_iterator iterator = data.begin(), end = data.end(); iterator != end; ++iterator ) { RooDataSet *dataset = dynamic_cast<RooDataSet *>( *iterator ); if (dataset) { RooDataSet *datasetReduced = (RooDataSet*) dataset->emptyClone(dataset->GetName(),dataset->GetName()); TRandom3 r; r.Rndm(); double x[dataset->numEntries()]; r.RndmArray(dataset->numEntries(),x); int desiredEntries = floor(0.5+ dataset->numEntries()*fraction_); int modFraction = floor(0.5+ 1/fraction_); int finalEventCount=0; for (int j =0; j < dataset->numEntries() ; j++){ if( j%modFraction==0){ finalEventCount++; } } float average_weight= dataset->sumEntries()/finalEventCount; for (int j =0; j < dataset->numEntries() ; j++){ if( j%modFraction==0){ dataset->get(j); datasetReduced->add(*(dataset->get(j)),average_weight); } } float entriesIN =dataset->sumEntries(); float entriesOUT =datasetReduced->sumEntries(); if(verbose_){ std::cout << "Original dataset " << *dataset <<std::endl; std::cout << "Reduced dataset " << *datasetReduced <<std::endl; std::cout << "********************************************" <<std::endl; std::cout << "fraction (obs) : " << entriesOUT/entriesIN << std::endl; std::cout << "fraction (exp) : " << fraction_ << std::endl; std::cout << "********************************************" <<std::endl; std::cout << "" <<std::endl; std::cout << "" <<std::endl; std::cout << "" <<std::endl; std::cout << "********************************************" <<std::endl; } outWS->import(*datasetReduced); } RooDataHist *datahist = dynamic_cast<RooDataHist *>( *iterator ); if (datahist) { RooDataHist *datahistOUT = (RooDataHist*) datahist->emptyClone(datahist->GetName(),datahist->GetName()); TRandom3 r; r.Rndm(); for (int j =0; j < datahist->numEntries() ; j++){ datahistOUT->add(*(datahist->get(j)),datahist->weight()); } float w =datahistOUT->sumEntries(); float z =datahist->sumEntries(); if(verbose_){ std::cout << "Original datahist " << *datahist <<std::endl; std::cout << "Reduced datahist " << *datahistOUT<<std::endl; std::cout << "********************************************" <<std::endl; std::cout << "WH fraction (obs) : " << w/(z) <<std::endl; std::cout << "WH fraction (exp) : " << fraction_ << std::endl; std::cout << "********************************************" <<std::endl; std::cout << "" <<std::endl; std::cout << "" <<std::endl; std::cout << "" <<std::endl; std::cout << "********************************************" <<std::endl; } outWS->import(*datahistOUT); } } saveDir->cd(); outWS->Write(); outfile->Close(); infile->Close(); } }
void wspaceread_signals2e2mu(int channel = 3) { gSystem->AddIncludePath("-I$ROOFITSYS/include"); gROOT->ProcessLine(".L ~/tdrstyle.C"); setTDRStyle(); //gSystem->Load("PDFs/RooRelBW1_cxx.so"); //gSystem->Load("PDFs/RooRelBW2_cxx.so"); gSystem->Load("../PDFs/HZZ4LRooPdfs_cc.so"); string schannel; if (channel == 1) schannel = "4mu"; if (channel == 2) schannel = "4e"; if (channel == 3) schannel = "2mu2e"; std::cout << "schannel = " << schannel << std::endl; const int nPoints = 17.; int masses[nPoints] = {120,130,140,150,160,170,180,190,200,250,300,350,400,450,500,550,600}; double mHVal[nPoints] = {120,130,140,150,160,170,180,190,200,250,300,350,400,450,500,550,600}; double widths[nPoints] = {3.48e-03,4.88e-03,8.14e-03,1.73e-02,8.30e-02,3.80e-01,6.31e-01,1.04e+00,1.43e+00,4.04e+00,8.43e+00,1.52e+01,2.92e+01,46.95,6.80e+01,93.15,1.23e+02}; // R e a d w o r k s p a c e f r o m f i l e // ----------------------------------------------- double a_meanBW[nPoints]; double a_gammaBW[nPoints]; double a_meanCB[nPoints]; double a_sigmaCB[nPoints]; double a_alphaCB[nPoints]; double a_nCB[nPoints]; for (int i = 0; i < nPoints; i++){ //for (int i = 0; i < 1; i++){ // Open input file with workspace (generated by rf14_wspacewrite) char infile[192]; sprintf(infile,"/scratch/hep/ntran/dataFiles/HZZ4L/datasets/datasets_baseline/%s/ZZAnalysisTree_H%i%s.root",schannel.c_str(),masses[i],schannel.c_str()); TFile *f = new TFile(infile) ; char outfile[192]; sprintf( outfile, "figs/pdf_%s_bkg_highmass.eps", schannel.c_str() ); //f->ls(); double windowVal = max( widths[i], 1. ); if (mHVal[i] >= 275){ lowside = 180.; } else { lowside = 100.; } double low_M = max( (mHVal[i] - 20.*windowVal), lowside) ; double high_M = min( (mHVal[i] + 15.*windowVal), 900.) ; //double windowVal = max( widths[i], 1.); //double windowVal = max ( widths[i], 1. ); //low_M = max( (mHVal[i] - 25.*windowVal), 100.) ; //high_M = min( (mHVal[i] + 20.*windowVal), 1000.) ; //low_M = max( (mHVal[i] - 15.*windowVal), 100.) ; //high_M = min( (mHVal[i] + 10.*windowVal), 1000.) ; std::cout << "lowM = " << low_M << ", highM = " << high_M << std::endl; RooDataSet* set = (RooDataSet*) f->Get("data"); RooArgSet* obs = set->get() ; obs->Print(); RooRealVar* CMS_zz4l_mass = (RooRealVar*) obs->find("CMS_zz4l_mass") ; CMS_zz4l_mass->setRange(low_M,high_M); for (int a=0 ; a<set->numEntries() ; a++) { set->get(a) ; //cout << CMS_zz4l_mass->getVal() << " = " << set->weight() << endl ; } // constraining parameters... double l_sigmaCB = 0., s_sigmaCB = 3.; if (mHVal[i] >= 500.){ l_sigmaCB = 10.; s_sigmaCB = 12.; } double s_n_CB = 2.6+(-1.1/290.)*(mHVal[i]-110.); if (mHVal[i] >= 400){ s_n_CB = 1.5; } RooRealVar mean_CB("mean_CB","mean_CB",0.,-25.,25); RooRealVar sigma_CB("sigma_CB","sigma_CB",s_sigmaCB,l_sigmaCB,30.); RooRealVar alpha_CB("alpha_CB","alpha_CB",0.95,0.8,1.2); RooRealVar n_CB("n_CB","n_CB",s_n_CB,1.5,2.8); RooCBShape signalCB("signalCB","signalCB",*CMS_zz4l_mass,mean_CB,sigma_CB,alpha_CB,n_CB); RooRealVar mean_BW("mean_BW","mean_BW", mHVal[i] ,100.,1000.); RooRealVar gamma_BW("gamma_BW","gamma_BW",widths[i],0.,200.); //RooBreitWigner signalBW("signalBW", "signalBW",*CMS_zz4l_mass,mean_BW,gamma_BW); //RooRelBW1 signalBW("signalBW", "signalBW",*CMS_zz4l_mass,mean_BW,gamma_BW); RooRelBWUF signalBW("signalBW", "signalBW",*CMS_zz4l_mass,mean_BW); //RooRelBW1 signalBW("signalBW", "signalBW",*CMS_zz4l_mass,mean_BW,gamma_BW); RooBreitWigner signalBW1("signalBW1", "signalBW1",*CMS_zz4l_mass,mean_BW,gamma_BW); RooRelBW1 signalBW2("signalBW2", "signalBW2",*CMS_zz4l_mass,mean_BW,gamma_BW); //Set #bins to be used for FFT sampling to 10000 CMS_zz4l_mass->setBins(100000,"fft") ; //Construct BW (x) CB RooFFTConvPdf* sig_ggH = new RooFFTConvPdf("sig_ggH","BW (X) CB",*CMS_zz4l_mass,signalBW,signalCB, 2); // Buffer fraction for cyclical behavior sig_ggH->setBufferFraction(0.2); mean_BW.setConstant(kTRUE); gamma_BW.setConstant(kTRUE); n_CB.setConstant(kTRUE); alpha_CB.setConstant(kTRUE); RooFitResult *r = sig_ggH.fitTo( *set, SumW2Error(kTRUE) );//, Save(kTRUE), SumW2Error(kTRUE)) ; a_meanBW[i] = mean_BW.getVal(); a_gammaBW[i] = gamma_BW.getVal(); a_meanCB[i] = mean_CB.getVal(); a_sigmaCB[i] = sigma_CB.getVal();; a_alphaCB[i] = alpha_CB.getVal();; a_nCB[i] = n_CB.getVal();; // Plot Y RooPlot* frameM4l = CMS_zz4l_mass->frame(Title("M4L"),Bins(100)) ; set->plotOn(frameM4l) ; sig_ggH.plotOn(frameM4l) ; RooPlot* testFrame = CMS_zz4l_mass->frame(Title("M4L"),Bins(100)) ; signalBW.plotOn(testFrame) ; signalBW1.plotOn(testFrame, LineColor(kBlack)) ; signalBW2.plotOn(testFrame, LineColor(kRed)) ; TCanvas *c = new TCanvas("c","c",800,600); c->cd(); frameM4l->Draw(); char plotName[192]; sprintf(plotName,"sigFigs/m%i.eps",masses[i]); c->SaveAs(plotName); TCanvas *c3 = new TCanvas("c3","c3",800,600); c3->cd(); testFrame->Draw(); //char plotName[192]; sprintf(plotName,"sigFigs/shape%i.eps",masses[i]); c3->SaveAs(plotName); delete f; delete set; delete c; } TGraph* gr_meanBW = new TGraph( nPoints, mHVal, a_meanBW ); TGraph* gr_gammaBW = new TGraph( nPoints, mHVal, a_gammaBW ); TGraph* gr_meanCB = new TGraph( nPoints, mHVal, a_meanCB ); TGraph* gr_sigmaCB = new TGraph( nPoints, mHVal, a_sigmaCB ); TGraph* gr_alphaCB = new TGraph( nPoints, mHVal, a_alphaCB ); TGraph* gr_nCB = new TGraph( nPoints, mHVal, a_nCB ); TF1 *polyFunc1= new TF1("polyFunc1","[0]+[1]*x+[2]*(x-[3])*(x-[3])+[4]*x*x*x*x", 120., 600.); polyFunc1->SetParameters(1., 1., 1., 100.,0.1); TF1 *polyFunc2= new TF1("polyFunc2","[0]+[1]*x+[2]*(x-[3])*(x-[3])+[4]*x*x*x*x", 120., 600.); polyFunc2->SetParameters(1., 1., 1., 100.,0.1); TCanvas *c = new TCanvas("c","c",1200,800); c->Divide(3,2); //c->SetGrid(); //TH1F *hr = c->DrawFrame(0.,0.,610.,1.); c->cd(1); gr_meanBW->Draw("alp"); gr_meanBW->GetXaxis()->SetTitle("mean BW"); c->cd(2); gr_gammaBW->Draw("alp"); gr_gammaBW->GetXaxis()->SetTitle("gamma BW"); c->cd(3); gr_meanCB->Fit(polyFunc1,"Rt"); gr_meanCB->Draw("alp"); gr_meanCB->GetXaxis()->SetTitle("mean CB"); c->cd(4); gr_sigmaCB->Fit(polyFunc2,"Rt"); gr_sigmaCB->Draw("alp"); gr_sigmaCB->GetXaxis()->SetTitle("sigma CB"); c->cd(5); gr_alphaCB->Draw("alp"); gr_alphaCB->GetXaxis()->SetTitle("alpha CB"); c->cd(6); gr_nCB->Draw("alp"); gr_nCB->GetXaxis()->SetTitle("n CB"); c->SaveAs("sigFigs/params.eps"); std::cout << "mean_CB = " << polyFunc1->GetParameter(0) << " + " << polyFunc1->GetParameter(1) << "*m + " << polyFunc1->GetParameter(2) << "*(m - " << polyFunc1->GetParameter(3) << ")*(m - " << polyFunc1->GetParameter(3); std::cout << ") + " << polyFunc1->GetParameter(4) << "*m*m*m*m;" << std::endl; std::cout << "sigma_CB = " << polyFunc2->GetParameter(0) << " + " << polyFunc2->GetParameter(1) << "*m + " << polyFunc2->GetParameter(2) << "*(m - " << polyFunc2->GetParameter(3) << ")*(m - " << polyFunc2->GetParameter(3); std::cout << ") + " << polyFunc2->GetParameter(4) << "*m*m*m*m;" << std::endl; // calculate sysetmatic errors from interpolation... double sum_meanCB = 0; double sum_sigmaCB = 0; for (int i = 0; i < nPoints; i++){ double tmp_meanCB = (polyFunc1->Eval(mHVal[i]) - a_meanCB[i]); sum_meanCB += (tmp_meanCB*tmp_meanCB); double tmp_sigmaCB = (polyFunc2->Eval(mHVal[i]) - a_sigmaCB[i])/a_sigmaCB[i]; sum_sigmaCB += (tmp_sigmaCB*tmp_sigmaCB); std::cout << "mean: " << tmp_meanCB << ", sigma: " << tmp_sigmaCB << std::endl; } double rms_meanCB = sqrt( sum_meanCB/( (double) nPoints) ); double rms_sigmaCB = sqrt( sum_sigmaCB/( (double) nPoints) ); std::cout << "err (meanCB) = " << rms_meanCB << ", err (sigmaCB) = " << rms_sigmaCB << std::endl; }
int main(int argc, const char** argv){ bool ReDoCuts=false; TCut TwelveCut = "gamma_CL>0.1&&BDT_response>0.36&&piplus_MC12TuneV3_ProbNNpi>0.2&&piminus_MC12TuneV3_ProbNNpi>0.2&&Kaon_MC12TuneV3_ProbNNk>0.4"; TCut ElevenCut = "gamma_CL>0.1&&BDT_response>0.30&&piplus_MC12TuneV3_ProbNNpi>0.2&&piminus_MC12TuneV3_ProbNNpi>0.2&&Kaon_MC12TuneV3_ProbNNk>0.4"; //______________________________MAKE CUT FILE FOR 2012___________________________________ if(ReDoCuts){ DataFile MCA(std::getenv("BUKETAPMCBDTRESPROOT"),MC,Twel,MagAll,buketap,"BDTApplied_SampleA"); DataFile MCB(std::getenv("BUKETAPMCBDTRESPROOT"),MC,Twel,MagAll,buketap,"BDTApplied_SampleB"); TreeReader* MC12Reader= new TreeReader("DecayTree"); MC12Reader->AddFile(MCA); MC12Reader->AddFile(MCB); MC12Reader->Initialize(); TFile* MC12Cut = new TFile("CutFile12.root","RECREATE"); TTree* MC12CutTree=MC12Reader->CopyTree(TwelveCut,-1,"DecayTree"); TRandom3 *MCRand = new TRandom3(224); TH1I * MCnCands12= new TH1I("MCnCands12","MCnCands12",10,0,10); TTree*MC12SingleTree=HandyFunctions::GetSingleTree(MCRand,MC12CutTree,MCnCands12,NULL); MCnCands12->Write(); MC12SingleTree->Write(); MC12Cut->Close(); //________________________________MAKE CUT FILE FOR 2011__________________________________ DataFile MC11A(std::getenv("BUKETAPMCBDTRESPROOT"),MC,Elev,MagAll,buketap,"BDTApplied_SampleA"); DataFile MC11B(std::getenv("BUKETAPMCBDTRESPROOT"),MC,Elev,MagAll,buketap,"BDTApplied_SampleB"); TreeReader* MC11Reader= new TreeReader("DecayTree"); MC11Reader->AddFile(MC11A); MC11Reader->AddFile(MC11B); MC11Reader->Initialize(); TFile* MC11Cut = new TFile("CutFile11.root","RECREATE"); TTree* MC11CutTree=MC11Reader->CopyTree(ElevenCut,-1,"DecayTree"); TH1I * MCnCands11= new TH1I("MCnCands11","MCnCands11",10,0,10); TTree* MC11SingleTree=HandyFunctions::GetSingleTree(MCRand,MC11CutTree,MCnCands11,NULL); MCnCands11->Write(); MC11SingleTree->Write(); MC11Cut->Close(); //_________________________________ MAKE FLAT TREES ____________________________________ TFile* MC12Input = new TFile("CutFile12.root"); TTree* MC12InputTree=(TTree*)MC12Input->Get("DecayTree"); Float_t MCEta_Mass12[20]; MC12InputTree->SetBranchAddress("Bu_DTFNoFix_eta_prime_M",&MCEta_Mass12); Int_t isSingle12; MC12InputTree->SetBranchAddress("isSingle",&isSingle12); TFile* MC12FlatOut = new TFile("MCMinimalFile12.root","RECREATE"); TTree* MC12FlatTree = MC12InputTree->CloneTree(0); Double_t MCBu_DTFNoFix_eta_Prime_MF12; MC12FlatTree->Branch("Bu_DTFNoFix_eta_prime_MF",&MCBu_DTFNoFix_eta_Prime_MF12,"Bu_DTFNoFix_eta_prime_MF/D"); Long64_t Entries12=MC12InputTree->GetEntries(); for(int i=0;i<Entries12;++i){ MC12InputTree->GetEntry(i); if(isSingle12==0)continue; MCBu_DTFNoFix_eta_Prime_MF12=MCEta_Mass12[0]; MC12FlatTree->Fill(); } MC12FlatTree->Write(); MC12FlatOut->Close(); TFile* MC11Input = new TFile("CutFile11.root"); TTree* MC11InputTree=(TTree*)MC11Input->Get("DecayTree"); Float_t MCEta_Mass11[20]; MC11InputTree->SetBranchAddress("Bu_DTFNoFix_eta_prime_M",&MCEta_Mass11); Int_t isSingle11; MC11InputTree->SetBranchAddress("isSingle",&isSingle11); TFile* MC11FlatOut = new TFile("MCMinimalFile11.root","RECREATE"); TTree* MC11FlatTree = MC11InputTree->CloneTree(0); Double_t MCBu_DTFNoFix_eta_Prime_MF11; MC11FlatTree->Branch("Bu_DTFNoFix_eta_prime_MF",&MCBu_DTFNoFix_eta_Prime_MF11,"Bu_DTFNoFix_eta_prime_MF/D"); Long64_t Entries11=MC11InputTree->GetEntries(); for(int i=0;i<Entries11;++i){ MC11InputTree->GetEntry(i); if(isSingle11==0)continue; MCBu_DTFNoFix_eta_Prime_MF11=MCEta_Mass11[0]; MC11FlatTree->Fill(); } MC11FlatTree->Write(); MC11FlatOut->Close(); } //_____________________________________________LOAD ROODATASETS___________________________________ TFile* MCFlatInput12= new TFile("MCMinimalFile12.root"); TTree* MCFlatInputTree12=(TTree*)MCFlatInput12->Get("DecayTree"); TFile* MCFlatInput11= new TFile("MCMinimalFile11.root"); TTree* MCFlatInputTree11=(TTree*)MCFlatInput11->Get("DecayTree"); RooRealVar MCBMass("Bu_DTF_MF","Bu_DTF_MF",5000.0,5600.0); RooRealVar MCEtaMass("eta_prime_MM","eta_prime_MM",700.0,1200.0); RooRealVar BDT_response("BDT_response","BDT_response",-1.0,1.0); RooRealVar gamma_CL("gamma_CL","gamma_CL",0.1,1.0); RooArgSet Args(MCBMass,MCEtaMass,BDT_response,gamma_CL); RooDataSet* MCData12 = new RooDataSet("MCData12","MCData12",Args,Import(*MCFlatInputTree12)); std::cout <<" Data File 12 Loaded"<<std::endl; RooDataSet* MCData11 = new RooDataSet("MCData11","MCData11",Args,Import(*MCFlatInputTree11)); std::cout<<" Data File 11 loaded"<<std::endl; RooDataSet* MCDataAll= new RooDataSet("MCDataAll","MCDataAll",Args); MCDataAll->append(*MCData12); MCDataAll->append(*MCData11); RooPlot* massFrame = MCBMass.frame(Title("Data Import Check"),Bins(50)); MCDataAll->plotOn(massFrame); RooPlot *BDTFrame = BDT_response.frame(Title("BDT Cut Check"),Bins(50)); MCDataAll->plotOn(BDTFrame); TCanvas C; C.Divide(2,1); C.cd(1); massFrame->Draw(); C.cd(2); BDTFrame->Draw(); C.SaveAs("ImportChecks.eps"); //________________________________MAKE MCROODATACATEGORIES__________________________________ RooDataSet* MCBData=(RooDataSet*)MCDataAll->reduce(RooArgSet(MCBMass)); MCBData->Print("v"); RooDataSet* MCEtaData=(RooDataSet*)MCDataAll->reduce(RooArgSet(MCEtaMass)); MCEtaData->Print("v"); RooCategory MCMassType("MCMassType","MCMassType") ; MCMassType.defineType("B") ; MCMassType.defineType("Eta") ; // Construct combined dataset in (x,sample) RooDataSet MCcombData("MCcombData","MC combined data",Args,Index(MCMassType),Import("B",*MCBData),Import("Eta",*MCEtaData)); //=============================================== MC FIT MODEL=================================== RooRealVar Mean("Mean","Mean",5279.29,5276.0,5284.00); RooRealVar Sigma("Sigma","Sigma",20.54,17.0,24.8); RooRealVar LAlpha("LAlpha","LAlpha",-1.064,-2.5,0.0); RooRealVar RAlpha("RAlpha","RAlpha",1.88,0.0,5.0); RooRealVar LN("LN","LN",13.0,0.0,40.0); RooRealVar RN("RN","RN",2.56,0.0,6.0); RooCBShape CBLeft("CBLeft","CBLeft",MCBMass,Mean,Sigma,LAlpha,LN); RooCBShape CBRight("CBRight","CBRight",MCBMass,Mean,Sigma,RAlpha,RN); RooRealVar FitFraction("FitFraction","FitFraction",0.5,0.0,1.0); RooAddPdf DCB("DCB","DCB",RooArgList(CBRight,CBLeft),FitFraction); RooRealVar SignalYield("SignalYield","SignalYield",4338.0,500.0,10000.0); // RooExtendPdf ExtDCB("ExtDCB","ExtDCB",DCB,SignalYield); //==============================ETA DCB ++++++++++++++++++++++++++++++ RooRealVar MCEtamean("MCEtamean","MCEtamean",958.0,955.0,960.0); RooRealVar MCEtasigma("MCEtasigma","MCEtasigma",9.16,8.0,14.0); RooRealVar EtaLAlpha("EtaLAlpha","EtaLAlpha",-1.45,-5.0,1.0); RooRealVar EtaRAlpha("EtaRAlpha","EtaRAlpha",1.76,0.0,4.0); RooRealVar EtaLN("EtaLN","EtaLN",0.1,0.0,20.0); RooRealVar EtaRN("EtaRN","EtaRN",0.1,0.0,20.0); RooCBShape EtaCBLeft("EtaCBLeft","EtaCBLeft",MCEtaMass,MCEtamean,MCEtasigma,EtaLAlpha,EtaLN); RooCBShape EtaCBRight("EtaCBRight","EtaCBRight",MCEtaMass,MCEtamean,MCEtasigma,EtaRAlpha,EtaRN); RooRealVar EtaFitFraction("EtaFitFraction","EtaFitFraction",0.22,0.1,1.0); RooAddPdf EtaDCB("EteaDCB","EtaDCB",RooArgList(EtaCBRight,EtaCBLeft),EtaFitFraction); RooProdPdf MCSignalPdf("MCSignalPdf","MCSignalPdf",RooArgSet(EtaDCB,DCB)); RooExtendPdf ExtendedMCSignalPdf("ExtendedMCSignalPdf","ExtendedMCSignalPdf",MCSignalPdf,SignalYield); RooSimultaneous MCsimPdf("MCsimPdf","MC simultaneous pdf",MCMassType) ; // MCsimPdf.addPdf(ExtDCB,"B"); // MCsimPdf.addPdf(ExtendedMCEtaDCB,"Eta"); //============================== DO the MC FIT ======================================= //MCsimPdf.fitTo(MCcombData,Extended(kTRUE),Minos(kTRUE)); //ExtendedMCEtaDCB.fitTo(*MCEtaData,Extended(kTRUE),Minos(kTRUE)); //ExtDCB.fitTo(*MCBData,Extended( ExtendedMCSignalPdf.fitTo(*MCDataAll,Extended(kTRUE),Minos(kTRUE)); RooPlot* MCframe1 = MCBMass.frame(Range(5100.0,5500.0),Bins(50),Title("B mass projection")); MCDataAll->plotOn(MCframe1); ExtendedMCSignalPdf.plotOn(MCframe1); ExtendedMCSignalPdf.paramOn(MCframe1); RooPlot* MCframe2 = MCEtaMass.frame(Range(880.0,1020.0),Bins(50),Title("Eta mass projection")) ; MCDataAll->plotOn(MCframe2); ExtendedMCSignalPdf.plotOn(MCframe2); ExtendedMCSignalPdf.paramOn(MCframe2); TCanvas* MCc = new TCanvas("rf501_simultaneouspdf","rf403_simultaneouspdf",1200,1000) ; gPad->SetLeftMargin(0.15) ; MCframe1->GetYaxis()->SetTitleOffset(1.4) ; MCframe1->Draw() ; MCc->SaveAs("MCSimulCanvas.pdf"); TCanvas* MCcEta = new TCanvas(" Eta Canvas","Eta Canvas",1200,1000); gPad->SetLeftMargin(0.15) ; MCframe2->GetYaxis()->SetTitleOffset(1.4) ; MCframe2->Draw() ; MCcEta->SaveAs("MCEtaCanvas.pdf"); TFile* MCFits= new TFile("MCFitResult.root","RECREATE"); // TCanvas* DecMCB=HandyFunctions::DecoratePlot(MCframe1); // TCanvas* DecMCEta=HandyFunctions::DecoratePlot(MCframe2); //DecMCEta->Write(); // DecMCB->Write(); MCc->Write(); MCcEta->Write(); std::cout<<"MC Eta Chi2 = "<<MCframe2->chiSquare()<<std::endl; std::cout<<"MC B Chi2 = "<<MCframe1->chiSquare()<<std::endl; //___________________________________ CUT DOWN COLLISION DATA ______________________________ if(ReDoCuts){ DataFile TwelveA(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Twel,MagAll,buketap,"BDTApplied_SampleA"); DataFile TwelveB(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Twel,MagAll,buketap,"BDTApplied_SampleB"); DataFile ElevenA(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Elev,MagAll,buketap,"BDTApplied_SampleA"); DataFile ElevenB(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Elev,MagAll,buketap,"BDTApplied_SampleB"); TRandom3* DataRand= new TRandom3(224); TH1I* DataNCand12= new TH1I("DataNCand12","DataNCand12",10,0,10); TH1I* DataNCand11= new TH1I("DataNCand11","DataNCand11",10,0,10); TreeReader* UncutDataReader12= new TreeReader("DecayTree"); UncutDataReader12->AddFile(TwelveA); UncutDataReader12->AddFile(TwelveB); UncutDataReader12->Initialize(); TFile* CutDataFile12 = new TFile("CutDataFile12.root","RECREATE"); TTree* CutDataTree12 = UncutDataReader12->CopyTree(TwelveCut,-1,"DecayTree"); TTree* SingleCutDataTree12=HandyFunctions::GetSingleTree(DataRand,CutDataTree12,DataNCand12,NULL); SingleCutDataTree12->Write(); CutDataFile12->Close(); TreeReader* UncutDataReader11= new TreeReader("DecayTree"); UncutDataReader11->AddFile(ElevenB); UncutDataReader11->AddFile(ElevenA); UncutDataReader11->Initialize(); TFile* CutDataFile11 = new TFile("CutDataFile11.root","RECREATE"); TTree* CutDataTree11 = UncutDataReader11->CopyTree(ElevenCut,-1,"DecayTree"); TTree* SingleCutDataTree11=HandyFunctions::GetSingleTree(DataRand,CutDataTree11,DataNCand11,NULL); SingleCutDataTree11->Write(); CutDataFile11->Close(); TFile* DataInput12 = new TFile("CutDataFile12.root"); TTree* DataInputTree12=(TTree*)DataInput12->Get("DecayTree"); DataInputTree12->SetBranchStatus("*",0); DataInputTree12->SetBranchStatus("Bu_DTF_MF",1); DataInputTree12->SetBranchStatus("Bu_DTFNoFix_eta_prime_M",1); DataInputTree12->SetBranchStatus("eta_prime_MM",1); DataInputTree12->SetBranchStatus("isSingle",1); Float_t Eta_Mass12[20]; DataInputTree12->SetBranchAddress("Bu_DTFNoFix_eta_prime_M",&Eta_Mass12); Int_t isSingle12; DataInputTree12->SetBranchAddress("isSingle",&isSingle12); TFile* MinimalDataFile12 = new TFile("MinimalDataFile12.root","RECREATE"); TTree* MinimalDataTree12= DataInputTree12->CloneTree(0); Double_t Bu_DTFNoFix_eta_prime_MF12; MinimalDataTree12->Branch("Bu_DTFNoFix_eta_prime_MF",&Bu_DTFNoFix_eta_prime_MF12,"Bu_DTFNoFix_eta_prime_MF/D"); Long64_t Entries12=DataInputTree12->GetEntries(); for(int i=0;i<Entries12;++i){ DataInputTree12->GetEntry(i); if(isSingle12==0)continue; Bu_DTFNoFix_eta_prime_MF12=Eta_Mass12[0]; MinimalDataTree12->Fill(); } MinimalDataTree12->Write(); MinimalDataFile12->Close(); TFile* DataInput11 = new TFile("CutDataFile11.root"); TTree* DataInputTree11=(TTree*)DataInput11->Get("DecayTree"); DataInputTree11->SetBranchStatus("*",0); DataInputTree11->SetBranchStatus("Bu_DTF_MF",1); DataInputTree11->SetBranchStatus("Bu_DTFNoFix_eta_prime_M",1); DataInputTree11->SetBranchStatus("eta_prime_MM",1); DataInputTree11->SetBranchStatus("isSingle",1); Float_t Eta_Mass11[20]; DataInputTree11->SetBranchAddress("Bu_DTFNoFix_eta_prime_M",&Eta_Mass11); Int_t isSingle11; DataInputTree11->SetBranchAddress("isSingle",&isSingle11); TFile* MinimalDataFile11 = new TFile("MinimalDataFile11.root","RECREATE"); TTree* MinimalDataTree11= DataInputTree11->CloneTree(0); Double_t Bu_DTFNoFix_eta_prime_MF11; MinimalDataTree11->Branch("Bu_DTFNoFix_eta_prime_MF",&Bu_DTFNoFix_eta_prime_MF11,"Bu_DTFNoFix_eta_prime_MF/D"); Long64_t Entries11=DataInputTree11->GetEntries(); for(int i=0;i<Entries11;++i){ DataInputTree11->GetEntry(i); if(isSingle11==0)continue; Bu_DTFNoFix_eta_prime_MF11=Eta_Mass11[0]; MinimalDataTree11->Fill(); } MinimalDataTree11->Write(); MinimalDataFile11->Close(); } //___________________________________ LOAD DATA TO ROODATASET____________________________________ RooRealVar BMass("Bu_DTF_MF","Bu_DTF_MF",5000.0,5600.0); RooRealVar EtaMass("eta_prime_MM","eta_prime_MM",870.0,1050.0); RooArgSet MassArgs(BMass,EtaMass); TFile* Data12File = new TFile("MinimalDataFile12.root"); TTree* DataTree12=(TTree*)Data12File->Get("DecayTree"); RooDataSet* Data12 = new RooDataSet("Data12","Data12",MassArgs,Import(*DataTree12)); TFile* Data11File = new TFile("MinimalDataFile11.root"); TTree* DataTree11=(TTree*)Data11File->Get("DecayTree"); RooDataSet* Data11 = new RooDataSet("Data11","Data11",MassArgs,Import(*DataTree11)); RooDataSet* AllData = new RooDataSet("AllData","AllData",MassArgs); AllData->append(*Data12); AllData->append(*Data11); TCanvas ImportC; RooPlot* ImportCheck = BMass.frame(Title("ImportCheck"),Bins(50)); AllData->plotOn(ImportCheck); ImportCheck->Draw(); ImportC.SaveAs("Alldataimport.pdf"); std::cout<<" Data Loaded, Total Entries = "<<AllData->numEntries()<<std::endl; AllData->Print("v"); RooDataSet* BData=(RooDataSet*)AllData->reduce(RooArgSet(BMass)); BData->Print("v"); RooDataSet* EtaData=(RooDataSet*)AllData->reduce(RooArgSet(EtaMass)); EtaData->Print("v"); //___________________________________Fit to Eta_Prime in BMass Sidebands______________________ RooDataSet* BSidebands=(RooDataSet*)AllData->reduce(Cut("(Bu_DTF_MF>5000.0&&Bu_DTF_MF<5179.0)||(Bu_DTF_MF>5379.0&&Bu_DTF_MF<5800.0)")); TCanvas BSidebandCanvas; RooPlot* BSidebandPlot = EtaMass.frame(Title("B sidebands"),Bins(30)); BSidebands->plotOn(BSidebandPlot); BSidebandPlot->Draw(); BSidebandCanvas.SaveAs("BSidebandDataCheck.pdf"); RooRealVar BsbMean(" Mean","BsbMean",958.0,900.0,1020.0); RooRealVar BsbSigma(" Sigma","BsbSigma",19.8,10.0,40.8); RooRealVar BsbLAlpha(" Alpha","BsbLAlpha",-1.63,-10.0,0.0); // RooRealVar BsbRAlpha("BsbRAlpha","BsbRAlpha",1.47,0.0,10.0); RooRealVar BsbLN(" N","BsbLN",0.1,0.0,20.0); // RooRealVar BsbRN("BsbRN","BsbRN",0.1,0.0,20.0); RooCBShape BsbCBLeft("BsbCBLeft","BsbCBLeft",EtaMass,BsbMean,BsbSigma,BsbLAlpha,BsbLN); // RooCBShape BsbCBRight("BsbCBRight","BsbCBRight",EtaMass,BsbMean,BsbSigma,BsbRAlpha,BsbRN); // RooRealVar BsbFitFraction("BsbFitFraction","BsbFitFraction",0.5,0.0,1.0); // RooAddPdf BsbDCB("BsbDCB","BsbDCB",RooArgList(BsbCBRight,BsbCBLeft),BsbFitFraction); RooRealVar Bsbslope("Bsbslope","Bsbslope",0.5,0.0,1.0); RooRealVar BsbP2("BsbP2","BsbP2",-0.5,-1.0,0.0); RooChebychev BsbLinear("BsbLinear","BsbLinear",EtaMass,RooArgSet(Bsbslope,BsbP2)); RooRealVar BsbFitFraction("BsbFitFraction","BsbFitFraction",0.2,0.0,1.0); RooAddPdf BsbBackground("BsbBackground","BsbBackground",RooArgList(BsbLinear,BsbCBLeft),BsbFitFraction); RooRealVar BsbYield(" Yield","BsbYield",500.0,0.0,1000.0); RooExtendPdf BsbExtDCB("BsbExtDCB","BsbExtDCB",BsbCBLeft,BsbYield); BsbExtDCB.fitTo(*BSidebands,Extended(kTRUE),Minos(kTRUE)); TCanvas BSBFitCanvas; RooPlot* BSBFitPlot = EtaMass.frame(Title("Eta fit in B Sidebands"),Bins(30)); BSidebands->plotOn(BSBFitPlot); BsbExtDCB.plotOn(BSBFitPlot); BsbExtDCB.paramOn(BSBFitPlot); BSBFitPlot->Draw(); BSBFitCanvas.SaveAs("BSidebandFit.pdf"); TFile * SidebandFitFile= new TFile("SidebandFit.root","RECREATE"); BSBFitCanvas.Write(); SidebandFitFile->Close(); //___________________________________DO THE 2D FIT TO DATA___________________________________ const double PDGBMass= 5279.26; BMass.setRange("SignalWindow",PDGBMass-(3*Sigma.getVal()),PDGBMass+(3*Sigma.getVal())); RooRealVar DSignalYield("DSignalYield","DSignalYield",4000.0,0.0,10000.0); //================================= B MASS SIGNAL PDF============================== RooRealVar DMean("Mean","DMean",5279.29,5270.0,5290.00); RooRealVar DSigma("Sigma","DSigma",19.8,10.0,40.8); RooRealVar DLAlpha("DLAlpha","DLAlpha",LAlpha.getVal()); RooRealVar DRAlpha("DRAlpha","DRAlpha",RAlpha.getVal()); RooRealVar DLN("DLN","DLN",LN.getVal()); RooRealVar DRN("DRN","DRN",RN.getVal()); RooCBShape DCBLeft("DCBLeft","DCBLeft",BMass,DMean,DSigma,DLAlpha,DLN); RooCBShape DCBRight("DCBRight","DCBRight",BMass,DMean,DSigma,DRAlpha,DRN); RooRealVar DFitFraction("FitFraction","DFitFraction",0.5,0.0,1.0); RooAddPdf DDCB("DDCB","DDCB",RooArgList(DCBRight,DCBLeft),DFitFraction); //==============================B MASS BKG PDF============================== RooRealVar slope("slope","slope",-0.5,-1.0,0.0); RooChebychev bkg("bkg","Background",BMass,RooArgSet(slope)); //==============================Eta mass signal pdf================================ RooRealVar DEtamean("Etamean","DEtamean",958.0,945.0,980.0) ; RooRealVar DEtasigma("Etasigma","DEtasigma",15.0,5.0,65.0) ; RooRealVar DEtaLAlpha("DEtaLAlpha","DEtaLAlpha",EtaLAlpha.getVal()); RooRealVar DEtaRAlpha("DEtaRAlpha","DEtaRAlpha",EtaRAlpha.getVal()); RooRealVar DEtaLN("DEtaLN","DEtaLN",EtaLN.getVal()); RooRealVar DEtaRN("DEtaRN","DEtaRN",EtaRN.getVal()); RooCBShape EtaDCBLeft("EtaDCBLeft","EtaDCBLeft",EtaMass,DEtamean,DEtasigma,DEtaLAlpha,DEtaLN); RooCBShape EtaDCBRight("EtaDCBRight","EtaDCBRight",EtaMass,DEtamean,DEtasigma,DEtaRAlpha,DEtaRN); RooRealVar DEtaFitFraction("EtaFitFraction","DEtaFitFraction",0.5,0.0,1.0); RooAddPdf EtaDDCB("EtaDDCB","EtaDDCB",RooArgList(EtaDCBRight,EtaDCBLeft),DEtaFitFraction); RooProdPdf DSignalPdf("DSignalPdf","DSignalPdf",RooArgList(EtaDDCB,DDCB)); RooExtendPdf DExtSignalPdf("DExtSignalPdf","DExtSignalPdf",DSignalPdf,DSignalYield); //=============================== Eta mass bkg pdf================================== RooRealVar EtaBkgMean("EtaBkgMean","EtaBkgMean",958.0,900.0,1020.0); RooRealVar EtaBkgSigma("EtaBkgSigma","EtaBkgSigma",19.8,10.0,40.8); RooRealVar EtaBkgLAlpha("EtaBkgLAlpha","EtaBkgLAlpha",BsbLAlpha.getVal()); // RooRealVar EtaBkgRAlpha("EtaBkgRAlpha","EtaBkgRAlpha",BsbRAlpha.getVal()); RooRealVar EtaBkgLN("EtaBkgLN","EtaBkgLN",BsbLN.getVal()); // RooRealVar EtaBkgRN("EtaBkgRN","EtaBkgRN",BsbRN.getVal()); RooCBShape EtaBkgCBLeft("EtaBkgCBLeft","EtaBkgCBLeft",EtaMass,DEtamean,EtaBkgSigma,EtaBkgLAlpha,EtaBkgLN); // RooCBShape EtaBkgCBRight("EtaBkgCBRight","EtaBkgCBRight",EtaMass,DEtamean,EtaBkgSigma,EtaBkgRAlpha,EtaBkgRN); // RooRealVar EtaBkgFitFraction("EtaBkgFitFraction","EtaBkgFitFraction",0.5,0.0,1.0); // RooAddPdf EtaBkgDCB("EtaBkgDCB","EtaBkgDCB",RooArgList(EtaBkgCBRight,EtaBkgCBLeft),EtaBkgFitFraction); RooProdPdf DataBackgroundPDF("DataBackgroundPDF","DataBackgroundPDF",RooArgList(EtaBkgCBLeft,bkg)); RooRealVar DataBackgroundYield("BackgroundYield","DataBackgroundYield",500.0,0.0,10000.0); RooExtendPdf ExtDataBackgroundPDF("ExtDataBackgroundPDF","ExtDataBackgroundPDF",DataBackgroundPDF,DataBackgroundYield); RooAddPdf TotalPDF("TotalPDF","TotalPDF",RooArgList(ExtDataBackgroundPDF,DExtSignalPdf)); std::cout<<"Dependents = "<<std::endl; RooArgSet* Dependents=TotalPDF.getDependents(AllData); Dependents->Print("v"); std::cout<<"parameters= "<<std::endl; RooArgSet* parameters=TotalPDF.getParameters(AllData); parameters->Print("v"); RooCategory MassType("MassType","MassType") ; MassType.defineType("B") ; MassType.defineType("Eta") ; // Construct combined dataset in (x,sample) RooDataSet combData("combData","combined data",MassArgs,Index(MassType),Import("B",*BData),Import("Eta",*EtaData)); RooSimultaneous simPdf("simPdf","simultaneous pdf",MassType) ; // Associate model with the physics state and model_ctl with the control state // simPdf.addPdf(WholeFit,"B"); // simPdf.addPdf(WholeEtaFit,"Eta"); // simPdf.fitTo(combData,Extended(kTRUE)/*,Minos(kTRUE)*/); TotalPDF.fitTo(*AllData,Extended(kTRUE),Minos(kTRUE)); RooPlot* frame1 = BMass.frame(Bins(50),Title("B mass projection")); AllData->plotOn(frame1); TotalPDF.plotOn(frame1,Components(ExtDataBackgroundPDF),LineStyle(kDashed),LineColor(kRed)); TotalPDF.plotOn(frame1); TotalPDF.paramOn(frame1); // The same plot for the control sample slice RooPlot* frame2 = EtaMass.frame(Bins(50),Title("Eta mass projection")) ; AllData->plotOn(frame2); TotalPDF.plotOn(frame2,Components(ExtDataBackgroundPDF),LineStyle(kDashed),LineColor(kRed)); TotalPDF.plotOn(frame2); TotalPDF.paramOn(frame2); TCanvas* DecoratedCanvas =HandyFunctions::DecoratePlot(frame2); TCanvas* DataBC= new TCanvas("BCanvas","BCanvas",1200,1000) ; gPad->SetLeftMargin(0.15) ; frame1->GetYaxis()->SetTitleOffset(1.4) ; frame1->Draw() ; TCanvas* EtaBC= new TCanvas("EtaCanvas","EtaCanvas",1200,1000) ; gPad->SetLeftMargin(0.15) ; frame2->GetYaxis()->SetTitleOffset(1.4) ; frame2->Draw() ; DataBC->SaveAs("DataBC.pdf"); EtaBC->SaveAs("EtaBC.pdf"); TFile * DataSimulFit = new TFile("DataSimulFit.root","RECREATE"); DataBC->Write(); EtaBC->Write(); DecoratedCanvas->Write(); }
void fitM3() { // LOAD HISTOGRAMS FROM FILES ///////////////////////////////// TH1F *hTTjets; TH1F *hWjets; TH1F *hM3; TH1F *hZjets; TH1F *hQCD; TH1F *hST_s; TH1F *hST_t; TH1F *hST_tW; // histograms from nonimal sample /////////// TFile *infile0 = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_TTJets-madgraph_Fall08_all_all.root"); //TFile *infile0 = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_TauolaTTbar.root"); hTTjets = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infile1 = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_WJets_madgraph_Fall08_all.root"); hWjets = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infile1Fast = TFile::Open("nominal_IPsig3_Iso95_Fast/TopAnalysis_Wjets_madgraph_Winter09_v2_all.root"); hWjetsFast = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileZ = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_ZJets_madgraph_Fall08_all.root"); hZjets = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileZFast = TFile::Open("nominal_IPsig3_Iso95_Fast/TopAnalysis_Zjets_madgraph_Winter09_v2_all.root"); hZjetsFast = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileST_s = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_ST_s.root"); hST_s = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileST_t = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_ST_t.root"); hST_t = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileST_tW = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_ST_tW.root"); hST_tW = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileQCD = TFile::Open("nominal_IPsig3_Iso95/TopAnalysis_InclusiveMuPt15_Summer08_all.root"); hQCD = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); // histograms from systematic samples ////////// TFile *infile0S = TFile::Open("nominal_JESUp/TopAnalysis_TTJets-madgraph_Fall08_all_all.root"); hTTjetsS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infile1S = TFile::Open("nominal_JESUp/TopAnalysis_WJets_madgraph_Fall08_all.root");// from FullSim hWjetsS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); //TFile *infile1SF = TFile::Open("nominal_JESUp_Fast/TopAnalysis_WJets_madgraph_Fall08_all.root");// from FastSim //TFile *infile1SF = TFile::Open("nominal_IPsig3_Iso95_Fast/TopAnalysis_Wjets_ScaleUp_madgraph_Winter09_all.root"); TFile *infile1SF = TFile::Open("nominal_IPsig3_Iso95_Fast/TopAnalysis_WJets_Threshold20GeV_madgraph_Winter09_all.root"); hWjetsSFast = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileZS = TFile::Open("nominal_JESUp/TopAnalysis_ZJets_madgraph_Fall08_all.root");// from FullSim hZjetsS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileZSF = TFile::Open("nominal_JESUp_Fast/TopAnalysis_ZJets_madgraph_Fall08_all.root");// from FullSim hZjetsSFast = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileST_sS = TFile::Open("nominal_JESUp/TopAnalysis_ST_s.root"); hST_sS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileST_tS = TFile::Open("nominal_JESUp/TopAnalysis_ST_t.root"); hST_tS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileST_tWS = TFile::Open("nominal_JESUp/TopAnalysis_ST_tW.root"); hST_tWS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); TFile *infileQCDS = TFile::Open("nominal_JESUp/TopAnalysis_InclusiveMuPt15_Summer08_all.root");// hQCDS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); //TFile *infileQCD_CS = TFile::Open("nominal_antiMuon/TopAnalysis_InclusiveMuPt15_Summer08_all.root"); //hQCD_CS = (TH1F*) gDirectory->Get("Mass/HadronicTop_mass_cut1"); // write templates to file //TFile *outfile = TFile::Open("templates.root","RECREATE"); //hTTjets->Write("ttbar"); //hWjets->Write("Wjets"); //outfile->Close(); // Add over/underflow bins if requested bool UseOverflow = true; bool UseUnderflow = true; if (UseOverflow) { int maxbin=hTTjets->GetNbinsX(); hTTjets->SetBinContent(maxbin, hTTjets->GetBinContent(maxbin+1)+hTTjets->GetBinContent(maxbin) ); hWjets->SetBinContent(maxbin, hWjets->GetBinContent(maxbin+1)+hWjets->GetBinContent(maxbin) ); hWjetsFast->SetBinContent(maxbin, hWjetsFast->GetBinContent(maxbin+1)+hWjetsFast->GetBinContent(maxbin) ); hZjets->SetBinContent(maxbin, hZjets->GetBinContent(maxbin+1)+hZjets->GetBinContent(maxbin) ); hZjetsFast->SetBinContent(maxbin, hZjetsFast->GetBinContent(maxbin+1)+hZjetsFast->GetBinContent(maxbin) ); hQCD->SetBinContent(maxbin, hQCD->GetBinContent(maxbin+1)+hQCD->GetBinContent(maxbin) ); //hQCD_CS->SetBinContent(maxbin, hQCD_CS->GetBinContent(maxbin+1)+hQCD_CS->GetBinContent(maxbin) ); hST_s->SetBinContent(maxbin, hST_s->GetBinContent(maxbin+1)+hST_s->GetBinContent(maxbin) ); hST_t->SetBinContent(maxbin, hST_t->GetBinContent(maxbin+1)+hST_t->GetBinContent(maxbin) ); hST_tW->SetBinContent(maxbin, hST_tW->GetBinContent(maxbin+1)+hST_tW->GetBinContent(maxbin) ); } //underflow bin if (UseUnderflow) { int maxbin=1; hTTjets->SetBinContent(maxbin, hTTjets->GetBinContent(maxbin-1)+hTTjets->GetBinContent(maxbin) ); hWjets->SetBinContent(maxbin, hWjets->GetBinContent(maxbin-1)+hWjets->GetBinContent(maxbin) ); hWjetsFast->SetBinContent(maxbin, hWjetsFast->GetBinContent(maxbin-1)+hWjetsFast->GetBinContent(maxbin) ); hZjets->SetBinContent(maxbin, hZjets->GetBinContent(maxbin-1)+hZjets->GetBinContent(maxbin) ); hZjetsFast->SetBinContent(maxbin, hZjetsFast->GetBinContent(maxbin-1)+hZjetsFast->GetBinContent(maxbin) ); hQCD->SetBinContent(maxbin, hQCD->GetBinContent(maxbin-1)+hQCD->GetBinContent(maxbin) ); //hQCD_CS->SetBinContent(maxbin, hQCD_CS->GetBinContent(maxbin-1)+hQCD_CS->GetBinContent(maxbin) ); hST_s->SetBinContent(maxbin, hST_s->GetBinContent(maxbin-1)+hST_s->GetBinContent(maxbin) ); hST_t->SetBinContent(maxbin, hST_t->GetBinContent(maxbin-1)+hST_t->GetBinContent(maxbin) ); hST_tW->SetBinContent(maxbin, hST_tW->GetBinContent(maxbin-1)+hST_tW->GetBinContent(maxbin) ); } //syst. if (UseOverflow) { int maxbin=hTTjetsS->GetNbinsX(); hTTjetsS->SetBinContent(maxbin, hTTjetsS->GetBinContent(maxbin+1)+hTTjetsS->GetBinContent(maxbin) ); hWjetsS->SetBinContent(maxbin, hWjetsS->GetBinContent(maxbin+1)+hWjetsS->GetBinContent(maxbin) ); hWjetsSFast->SetBinContent(maxbin, hWjetsSFast->GetBinContent(maxbin+1)+hWjetsSFast->GetBinContent(maxbin) ); hZjetsS->SetBinContent(maxbin, hZjetsS->GetBinContent(maxbin+1)+hZjetsS->GetBinContent(maxbin) ); hZjetsSFast->SetBinContent(maxbin, hZjetsSFast->GetBinContent(maxbin+1)+hZjetsSFast->GetBinContent(maxbin) ); hQCDS->SetBinContent(maxbin, hQCDS->GetBinContent(maxbin+1)+hQCDS->GetBinContent(maxbin) ); hST_sS->SetBinContent(maxbin, hST_sS->GetBinContent(maxbin+1)+hST_sS->GetBinContent(maxbin) ); hST_tS->SetBinContent(maxbin, hST_tS->GetBinContent(maxbin+1)+hST_tS->GetBinContent(maxbin) ); hST_tWS->SetBinContent(maxbin, hST_tWS->GetBinContent(maxbin+1)+hST_tWS->GetBinContent(maxbin) ); } if (UseUnderflow) { //underflow bin int maxbin=1; hTTjetsS->SetBinContent(maxbin, hTTjetsS->GetBinContent(maxbin-1)+hTTjetsS->GetBinContent(maxbin) ); hWjetsS->SetBinContent(maxbin, hWjetsS->GetBinContent(maxbin-1)+hWjetsS->GetBinContent(maxbin) ); hWjetsSFast->SetBinContent(maxbin, hWjetsSFast->GetBinContent(maxbin-1)+hWjetsSFast->GetBinContent(maxbin) ); hZjetsS->SetBinContent(maxbin, hZjetsS->GetBinContent(maxbin-1)+hZjetsS->GetBinContent(maxbin) ); hZjetsSFast->SetBinContent(maxbin, hZjetsSFast->GetBinContent(maxbin-1)+hZjetsSFast->GetBinContent(maxbin) ); hQCDS->SetBinContent(maxbin, hQCDS->GetBinContent(maxbin-1)+hQCDS->GetBinContent(maxbin) ); hST_sS->SetBinContent(maxbin, hST_sS->GetBinContent(maxbin-1)+hST_sS->GetBinContent(maxbin) ); hST_tS->SetBinContent(maxbin, hST_tS->GetBinContent(maxbin-1)+hST_tS->GetBinContent(maxbin) ); hST_tWS->SetBinContent(maxbin, hST_tWS->GetBinContent(maxbin-1)+hST_tWS->GetBinContent(maxbin) ); } // scale histograms to 20/pb hTTjets->Scale(0.0081); // madgraph //hTTjets->Scale(0.0777);//Tauola hWjets->Scale(0.0883); //hWjetsFast->Scale(0.0091); //fastsim hWjetsFast->Scale(hWjets->Integral() / hWjetsFast->Integral()); // scale to FullSim hZjets->Scale(0.0731); hZjetsFast->Scale(hZjets->Integral()/hZjetsFast->Integral()); //scale to FullSim hQCD->Scale(0.4003); hQCD_WFast = (TH1F*) hWjetsFast->Clone("hQCD_WFast"); //take shape from Wjets hQCD_WFast->Scale(hQCD->Integral()/hQCD_WFast->Integral()); //scale to FullSim hST_t->Scale(0.003); hST_s->Scale(0.0027); hST_tW->Scale(0.0034); hTTjetsS->Scale(0.0081); // //hTTjetsS->Scale(0.0008); // for fastsim hWjetsS->Scale(0.0883); //hWjetsS->Scale(0.0091);// from fastsim //hWjetsSFast->Scale(hWjetsS->Integral() / hWjetsSFast->Integral()); // scale to FullSim //hWjetsSFast->Scale(0.6642); // scaleUP //hWjetsSFast->Scale(0.8041); // scaleDown //hWjetsSFast->Scale(0.0605); // threshold 5gev hWjetsSFast->Scale(0.042); // threshold 20gev hZjetsS->Scale(0.0731); //hZjetsS->Scale(0.0085);// from fastsim hZjetsSFast->Scale(hZjetsS->Integral() / hZjetsSFast->Integral()); // scale to FullSim hQCDS->Scale(0.4003); //hQCDS_WFast = (TH1F*) hWjetsS->Clone("hQCDS_WFast"); //hQCDS_WFast->Scale(hQCDS->Integral()/hQCDS_WFast->Integral()); hST_tS->Scale(0.003); hST_sS->Scale(0.0027); hST_tWS->Scale(0.0034); cout << " N expected ttbar+jets events = " << hTTjets->Integral() << endl; cout << " N expected W+jets events = " << hWjets->Integral() << endl; cout << " N expected Z+jets events = " << hZjets->Integral() << endl; cout << " N expected ST s events = " << hST_s->Integral() << endl; cout << " N expected ST t events = " << hST_t->Integral() << endl; cout << " N expected ST tW events = " << hST_tW->Integral() << endl; cout << " N expected qcd events = " << hQCD->Integral() << endl; cout << endl; cout << " N expected W+jets fast = " << hWjetsFast->Integral() << endl; cout << " N expected z+jets fast = " << hZjetsFast->Integral() << endl; cout << " N expected qcd Wfast = " << hQCD_WFast->Integral() << endl; cout << "\n systematics: " << endl; cout << " N expected W+jets fast = " << hWjetsSFast->Integral() << endl; cout << " N expected z+jets fast = " << hZjetsS->Integral() << endl; cout << " N expected qcd Wfast = " << hQCDS->Integral() << endl; // add all three single top samples // for systematics //hST_t->Scale(2.); hST_t->Add(hST_s); hST_t->Add(hST_tW); cout << " number of ST = " << hST_t->Integral() << endl; // syst. uncertainty in single top //double tmpST = 0.6* hST_t->Integral(); //hST_t->Scale(0.6); //cout << tmpST << endl; cout << " New number of ST = " << hST_t->Integral() << endl; hST_tS->Add(hST_sS); hST_tS->Add(hST_tWS); // dump scaled histograms in root file //TFile *output = TFile::Open("fitM3.root","RECREATE"); //hTTjets->SetName("ttbar");hTTjets->Write(); //hWjetsFast->SetName("WjetsFast");hWjetsFast->Write(); //hST_t->SetName("ST");hST_t->Write(); //output->Close(); hM3 = (TH1F*) hTTjets->Clone("hM3"); hM3->Add(hWjets); hM3->Add(hZjets); hM3->Add(hQCD); hM3->Add(hST_t); int Nbins = hM3->GetNbinsX(); // --- Observable --- RooRealVar mass("mass","M3'(#chi^{2})",100,500,"GeV/c^{2}") ; RooRealVar Ntt("Ntt","number of t#bar{t} events", hTTjets->Integral(), -100 , 1000); RooRealVar NW("NW","number of W+jets events", hWjetsFast->Integral(), -500 , 1000); RooRealVar NST("NST","number of single top events", hST_t->Integral(), -500,100); RooRealVar NZjets("NZjets","number of Z+jets events", hZjetsS->Integral(), -500,500); RooRealVar Nqcd("Nqcd","number of QCD events", hQCD_WFast->Integral(), -500,100); //RooRealVar Nbkg("Nbkg","number of bkg events", hWjetsFast->Integral()+hST_t->Integral()+hZjetsFast->Integral()+hQCD_WFast->Integral(), -500 , 1000); //RooRealVar Nbkg("Nbkg","number of W+jets events", hWjets->Integral(), -500 , 1000); // 2 templates RooRealVar Nbkg("Nbkg","number of bkg events", hWjetsFast->Integral()+hZjets->Integral()+hQCD_WFast->Integral(), -500 , 1000); //RooRealVar Nbkg("Nbkg","number of bkg events", hWjetsFast->Integral(), -500 , 1000); // for systematics //RooRealVar Nbkg("Nbkg","number of bkg events", hWjetsSFast->Integral()+hZjetsS->Integral()+hQCDS->Integral(), -500 , 1000); //RooRealVar Nbkg("Nbkg","number of bkg events", hWjetsSFast->Integral(), -500 , 1000); mass.setBins(Nbins); // RooFit datasets RooDataHist hdata_ttbar("hdata_ttbar","ttbar", mass, hTTjets); //RooDataHist hdata_wjets("hdata_wjets","wjets", mass, hWjets); RooDataHist hdata_wjetsFast("hdata_wjetsFast","wjets_Fast", mass, hWjetsFast); RooDataHist hdata_ST("hdata_ST","ST", mass, hST_t); RooDataHist hdata_zjets("hdata_zjets","zjets", mass, hZjets); //RooDataHist hdata_qcd("hdata_qcd","qcd", mass, hQCD); RooDataHist hdata_zjetsFast("hdata_zjetsFast","zjets_Fast", mass, hZjetsFast); RooDataHist hdata_qcdWFast("hdata_qcdWFast","qcd WFast", mass, hQCD_WFast); RooHistPdf hpdf_ttbar("hpdf_ttbar","signal pdf", mass, hdata_ttbar, 0 ); //RooHistPdf hpdf_wjets("hpdf_wjets","W+jets pdf", mass, hdata_wjets, 0 ); RooHistPdf hpdf_wjetsFast("hpdf_wjetsFast","W+jets pdf", mass, hdata_wjetsFast, 0 ); RooHistPdf hpdf_ST("hpdf_ST","ST pdf", mass, hdata_ST, 0 ); //RooHistPdf hpdf_zjets("hpdf_zjets","Z+jets pdf", mass, hdata_zjets, 0 ); //RooHistPdf hpdf_qcd("hpdf_qcd","qcd pdf", mass, hdata_qcd, 0 ); RooHistPdf hpdf_zjetsFast("hpdf_zjetsFast","Z+jets pdf", mass, hdata_zjetsFast, 0 ); RooHistPdf hpdf_qcdWFast("hpdf_qcdWFast","qcd WFast pdf", mass, hdata_qcdWFast, 0 ); // for systematics RooDataHist hdata_ttbarS("hdata_ttbarS","ttbar", mass, hTTjetsS); RooDataHist hdata_wjetsS("hdata_wjetsS","wjets", mass, hWjetsSFast); RooDataHist hdata_STS("hdata_STS","ST", mass, hST_tS); RooDataHist hdata_zjetsS("hdata_zjetsS","zjets", mass, hZjetsSFast); RooDataHist hdata_qcdS("hdata_qcdS","qcd", mass, hQCDS); //RooDataHist hdata_qcdSWFast("hdata_qcdSWFast","qcd WFast", mass, hQCDS_WFast); RooHistPdf hpdf_ttbarS("hpdf_ttbarS","signal pdf", mass, hdata_ttbarS, 0 ); RooHistPdf hpdf_wjetsS("hpdf_wjetsS","W+jets pdf", mass, hdata_wjetsS, 0 ); RooHistPdf hpdf_STS("hpdf_STS","ST pdf", mass, hdata_STS, 0 ); RooHistPdf hpdf_zjetsS("hpdf_zjetsS","Z+jets pdf", mass, hdata_zjetsS, 0 ); RooHistPdf hpdf_qcdS("hpdf_qcdS","qcd pdf", mass, hdata_qcdS, 0 ); //RooHistPdf hpdf_qcdSWFast("hpdf_qcdSWFast","qcd WFast pdf", mass, hdata_qcdSWFast, 0 ); //RooAddPdf hpdf_bkg("hpdf_bkg","bkg", RooArgList(hpdf_wjetsFast,hpdf_ST,hpdf_qcdWFast), // RooArgList(NW,NST,Nqcd) ); //RooAddPdf hpdf_bkg("hpdf_bkg","bkg", RooArgList(hpdf_wjetsFast,hpdf_ST,hpdf_zjetsFast,hpdf_qcdWFast), //RooAddPdf hpdf_bkg("hpdf_bkg","bkg", RooArgList(hpdf_wjetsS,hpdf_STS,hpdf_zjetsS,hpdf_qcdSWFast), //RooArgList(NW,NST,NZjets,Nqcd) ); // only two pdfs: ttbar + Wjets //RooHistPdf hpdf_bkg = hpdf_wjetsFast; //RooAddPdf model_M3("modelM3","all", RooArgList(hpdf_ttbar,hpdf_wjetsFast,hpdf_ST,hpdf_zjetsFast,hpdf_qcdWFast), // RooArgList(Ntt,Nbkg,NST,NZjets,Nqcd)); // for systematics RooAddPdf model_M3("modelM3","all", RooArgList(hpdf_ttbar,hpdf_wjetsFast,hpdf_ST),//RooArgList(hpdf_ttbar,hpdf_wjetsS,hpdf_ST), RooArgList(Ntt,Nbkg,NST) ); //RooAddPdf model_M3("modelM3","all",RooArgList(hpdf_ttbar,hpdf_bkg), // RooArgList(Ntt,Nbkg) ); //RooArgList(Ntt,Nbkg,NST,Nqcd) ); RooAddPdf model_histpdf("model", "TTjets+Wjets", RooArgList(hpdf_ttbar,hpdf_wjetsFast,hpdf_ST), RooArgList(Ntt, Nbkg, NST) ) ; // Construct another Gaussian constraint p.d.f on parameter f at n with resolution of sqrt(n) RooGaussian STgaussConstraint("STgaussConstraint","STgaussConstraint",NST,RooConst(hST_t->Integral()),RooConst(sqrt(hST_t->Integral() + (0.3*hST_t->Integral())*(0.3*hST_t->Integral()))) ); //RooGaussian fconstext2("fconstext2","fconstext2",NZjets,RooConst(hZjets->Integral()),RooConst(sqrt(hZjets->Integral())) ); // --- Generate a toyMC sample //RooMCStudy *mcstudyM3 = new RooMCStudy(model_M3, mass, Binned(kTRUE),Silence(),Extended(), // FitOptions(Save(kTRUE),Minos(kTRUE),Extended(), ExternalConstraints(fconstext)) ); // generate PEs int Nsamples = 1000; // PEs for ttbar /* RooExtendPdf ext_hpdf_ttbar("ext_hpdf_ttbar","ext_hpdf_ttbar",hpdf_ttbar,Ntt); RooExtendPdf ext_hpdf_wjets("ext_hpdf_wjets","ext_hpdf_wjets",hpdf_wjetsFast,NW); RooExtendPdf ext_hpdf_zjets("ext_hpdf_zjets","ext_hpdf_zjets",hpdf_zjetsFast,NZjets); RooExtendPdf ext_hpdf_qcd("ext_hpdf_qcd","ext_hpdf_qcd",hpdf_qcdWFast,Nqcd); RooExtendPdf ext_hpdf_ST("ext_hpdf_ST","ext_hpdf_ST",hpdf_ST,NST); RooMCStudy *mc_ttbar = new RooMCStudy(ext_hpdf_ttbar,mass,Binned(kTRUE),Silence(kTRUE)); mc_ttbar->generate(Nsamples,0,kFALSE,"data/toymc_ttbar_%04d.dat"); RooMCStudy *mc_wjets = new RooMCStudy(ext_hpdf_wjets,mass,Binned(kTRUE),Silence(kTRUE)); mc_wjets->generate(Nsamples,0,kFALSE,"data/toymc_wjets_%04d.dat"); RooMCStudy *mc_zjets = new RooMCStudy(ext_hpdf_zjets,mass,Binned(kTRUE),Silence(kTRUE)); mc_zjets->generate(Nsamples,0,kFALSE,"data/toymc_zjets_%04d.dat"); RooMCStudy *mc_qcd = new RooMCStudy(ext_hpdf_qcd,mass,Binned(kTRUE),Silence(kTRUE)); mc_qcd->generate(Nsamples,0,kFALSE,"data/toymc_qcd_%04d.dat"); RooMCStudy *mc_ST = new RooMCStudy(ext_hpdf_ST,mass,Binned(kTRUE),Silence(kTRUE),FitOptions(ExternalConstraints(STgaussConstraint))); mc_ST->generate(Nsamples,0,kFALSE,"data/toymc_ST_%04d.dat"); return; */ RooMCStudy *mcstudy = new RooMCStudy(model_M3, mass, FitModel(model_histpdf),Binned(kTRUE),Silence(kTRUE), Extended() , //FitOptions(Save(kTRUE),Minos(kTRUE),Extended()) ); FitOptions(Save(kTRUE),Minos(kTRUE),Extended(),ExternalConstraints(STgaussConstraint)));//RooArgList(fconstext,fconstext2)) )); //gaussian constraint //mcstudyM3->generate(Nsamples,0,kFALSE,"toymc.dat"); //mcstudyM3->generateAndFit(Nsamples,0,kFALSE,"toymc.dat"); //TList dataList; //for (int isample=0; isample<Nsamples; ++isample) dataList.Add( mcstudyM3->genData(isample)); // Fit mcstudy->generateAndFit(Nsamples,0,kTRUE); //mcstudy->fit(Nsamples, "data/toymc_%04d.dat"); gDirectory->Add(mcstudy) ; // E x p l o r e r e s u l t s o f s t u d y // ------------------------------------------------ // Make plots of the distributions of mean, the error on mean and the pull of mean RooPlot* frame1 = mcstudy->plotParam(Ntt,Bins(40)); RooPlot* frame2 = mcstudy->plotError(Ntt,Bins(40)) ; RooPlot* frame3 = mcstudy->plotPull(Ntt,Bins(40),FitGauss(kTRUE)) ; RooPlot* frame1w = mcstudy->plotParam(Nbkg,Bins(40)) ; RooPlot* frame2w = mcstudy->plotError(Nbkg,Bins(40)) ; RooPlot* frame3w = mcstudy->plotPull(Nbkg,Bins(40),FitGauss(kTRUE)) ; RooPlot* frame1st = mcstudy->plotParam(NST,Bins(40)) ; RooPlot* frame2st = mcstudy->plotError(NST,Bins(40)) ; //RooPlot* frame3st = mcstudy->plotPull(NST,Bins(40),FitGauss(kTRUE)) ; // Plot distribution of minimized likelihood RooPlot* frame4 = mcstudy->plotNLL(Bins(40)) ; // Make some histograms from the parameter dataset TH1* hh_cor_ttbar_w = mcstudy->fitParDataSet().createHistogram("hh",Ntt,YVar(Nbkg)) ; // Access some of the saved fit results from individual toys //TH2* corrHist000 = mcstudy->fitResult(0)->correlationHist("c000") ; //TH2* corrHist127 = mcstudy->fitResult(127)->correlationHist("c127") ; //TH2* corrHist953 = mcstudy->fitResult(953)->correlationHist("c953") ; // Draw all plots on a canvas gStyle->SetPalette(1) ; gStyle->SetOptStat(0) ; TCanvas* cv = new TCanvas("cv","cv",600,600) ; hM3->SetFillColor(kRed); hWjets->SetFillColor(kGreen); hM3->Draw(); hWjets->Draw("same"); gPad->RedrawAxis(); TCanvas* cva = new TCanvas("cva","cva",1800,600) ; cva->Divide(3); cva->cd(1) ; RooPlot *initialframe = mass.frame(); //initial->SetMaximum(10); hpdf_ttbar.plotOn(initialframe,LineColor(kRed)); hpdf_wjetsFast.plotOn(initialframe,LineColor(kGreen)); hpdf_ST.plotOn(initialframe,LineColor(kYellow)); initialframe->Draw(); //initialframe->SetTitle(); cva->cd(2); //retrieve data for only one PE int Npe = 10; RooPlot *genframe = mass.frame(Nbins); RooDataSet *gendata = mcstudy->genData(Npe); cout << " N events = " << gendata->numEntries() << endl; gendata->plotOn(genframe); //mcstudy->fitResult(Npe)->plotOn(genframe, model_histpdf); genframe->Draw(); cva->cd(3); RooPlot *genframe2 = mass.frame(Nbins); mcstudy->fitResult(Npe)->Print("v"); gendata->plotOn(genframe2); RooArgList arglist = mcstudy->fitResult(Npe)->floatParsFinal(); //cout << "name of argument:" << arglist[2].GetName() << endl; //cout << "name of argument:" << arglist[1].GetName() << endl; //cout << "name of argument:" << arglist[0].GetName() << endl; RooAddPdf model_histpdf_fitted("modelfitted", "TTjets+Wjets", RooArgList(hpdf_ttbar,hpdf_wjetsFast,hpdf_ST), RooArgList(arglist[2],arglist[1],arglist[0]) ) ; model_histpdf_fitted.plotOn(genframe2,LineColor(kRed)); model_histpdf_fitted.plotOn(genframe2,Components(hpdf_wjetsFast),LineColor(kGreen)); model_histpdf_fitted.plotOn(genframe2,Components(hpdf_ST),LineColor(kYellow)); genframe2->Draw(); TCanvas* cvb = new TCanvas("cvb","cvb",1800,600) ; cvb->Divide(3); cvb->cd(1) ; frame1->Draw(); cvb->cd(2) ; frame2->Draw(); cvb->cd(3) ; frame3->Draw(); TCanvas* cvbb = new TCanvas("cvbb","cvbb",1800,600) ; cvbb->Divide(3); cvbb->cd(1) ; frame1w->Draw(); cvbb->cd(2) ; frame2w->Draw(); cvbb->cd(3) ; frame3w->Draw(); TCanvas* cvbbb = new TCanvas("cvbbb","cvbbb",1200,600) ; cvbbb->Divide(2); cvbbb->cd(1) ; frame1st->Draw(); cvbbb->cd(2) ; frame2st->Draw(); //cvbbb->cd(3) ; frame3st->Draw(); TCanvas* cvbc = new TCanvas("cvbc","cvbc",600,600) ; TH2 *h2 = Ntt.createHistogram("Nttbar vs NWjets",Nbkg); mcstudy->fitParDataSet().fillHistogram(h2,RooArgList(Ntt,Nbkg)); h2->Draw("box"); TCanvas* cvc = new TCanvas("cvc","cvc",600,600) ; // Plot distribution of minimized likelihood RooPlot* frame4 = mcstudy->plotNLL(Bins(40)) ; frame4->Draw(); //return;//debuging TCanvas* cvd = new TCanvas("cvd","cvd",600,600) ; TCanvas* cve = new TCanvas("cve","cve",1200,600) ; TCanvas* cvf = new TCanvas("cvf","cvf",600,600) ; TH1F *hNgen = new TH1F("hNgen","Number of observed events",30,350,650); hNgen->SetXTitle("Number of observed events"); TH1F *hNttresults = new TH1F("hNttresults","number of ttbar events",50,20,600); TH1F *hNWresults = new TH1F("hNWresults","number of W events",50,-150,400); TH1F *hNSTresults = new TH1F("hNSTresults","number of ttbar events",50,5,25); bool gotone = false; int Nfailed = 0; for ( int i=0; i< Nsamples; i++) { RooFitResult *r = mcstudy->fitResult(i); RooArgList list = r->floatParsFinal(); RooRealVar *rrv_nt = (RooRealVar*)list.at(2); double nt = rrv_nt->getVal(); //double nte= rrv_nt->getError(); RooRealVar *rrv_nw = (RooRealVar*)list.at(1); double nw = rrv_nw->getVal(); //double nwe= rrv_nw->getError(); RooRealVar *rrv_nst = (RooRealVar*)list.at(0); double nst = rrv_nst->getVal(); hNttresults->Fill(nt); hNWresults->Fill(nw); hNSTresults->Fill(nst); RooDataSet *adata = mcstudy->genData(i); hNgen->Fill(adata->numEntries()); if ( r->numInvalidNLL() > 0 ) Nfailed++; /* if ( false ) { cout << " sample # " << i << endl; gotone = true; r->Print("v"); cout << " invalidNLL = "<< r->numInvalidNLL() << endl; cout << " N events = " << adata->numEntries() << endl; RooAddPdf amodel("amodel", "TTjets+Wjets", RooArgList(hpdf_ttbar,hpdf_wjets,hpdf_ST), RooArgList(list[2],list[1],list[0])) ; RooPlot *d2 = new RooPlot(Ntt,NW,0,500,-200,200); r->plotOn(d2,Ntt,NW,"ME12ABHV"); cvd->cd(); d2->Draw(); RooNLLVar nll("nll","nll", amodel, *adata, Extended() );//, Extended(), PrintEvalErrors(-1) ); RooMinuit myminuit(nll) myminuit.migrad(); myminuit.hesse(); myminuit.minos(); //myminuit.Save()->Print("v"); cve->Divide(2); RooPlot *nllframett = Ntt.frame(Bins(50),Range(100,600));//,Range(10,2000)); nll.plotOn(nllframett);//,ShiftToZero()); RooProfileLL pll_ntt("pll_ntt","pll_ntt",nll,Ntt); pll_ntt.plotOn(nllframett,LineColor(kRed)); RooPlot *nllframeW = NW.frame(Bins(50),Range(0,250));//,Range(10,2000)); nll.plotOn(nllframeW);//,ShiftToZero()); RooProfileLL pll_nW("pll_nW","pll_nW",nll,NW); pll_nW.plotOn(nllframeW,LineColor(kRed)); cve->cd(1); nllframett->SetMaximum(2); nllframett->Draw(); cve->cd(2); nllframeW->SetMaximum(2); nllframeW->Draw(); } */ } TCanvas *tmpcv = new TCanvas("tmpcv","tmpcv",700,700); cout << "\n ==================================" << endl; cout << "gaussian fit of Nttbar fitted values: " << endl; //hNttresults->Print("all"); hNttresults->Fit("gaus"); cout << "\n ==================================" << endl; cout << "gaussian fit of NW fitted values: " << endl; //hNWresults->Print("all"); hNWresults->Fit("gaus"); cout << "\n ==================================" << endl; cout << "gaussian fit of NST fitted values: " << endl; //hNSTresults->Print("all"); hNSTresults->Fit("gaus"); cout << "N failed fits = " << Nfailed << endl; cvf->cd(); hNgen->Draw(); // Make RooMCStudy object available on command line after // macro finishes //gDirectory->Add(mcstudy) ; }
void crossfeeds_nondiag(TString title, TString bkgfile, TString epsfile, TString txtfile, Double_t alpha_, Double_t mass_, Double_t n_, Double_t sigma_ ) { RooRealVar mbc("mbc", "m_{BC}", 1.83, 1.89, "GeV"); RooRealVar ebeam("ebeam", "Ebeam", 0., 100., "GeV"); RooRealVar chg("chg", "Charge", -2, 2); RooCategory passed("passed", "Event should be used for plot"); passed.defineType("yes", 1); passed.defineType("no", 0); RooRealVar arg_cutoff ("arg_cutoff", "Argus cutoff", 1.8865, 1.885, 1.8875,"GeV"); RooRealVar arg_slope ("arg_slope", "Argus slope", -13, -100, 40); RooRealVar mbc_float ("mbc_float", "Floating D mass", mass_, "GeV"); RooRealVar sigma ("sigma", "CB width", sigma_, "GeV"); RooRealVar alpha("alpha", "CB shape cutoff", alpha_); RooRealVar n("n", "CB tail parameter", n_); RooCBShape cb_float ("cb_float", "Floating Crystal Barrel", mbc, mbc_float, sigma, alpha, n); RooArgusBG argus("argus", "Argus BG", mbc, arg_cutoff, arg_slope); RooRealVar yld("yield", "D yield", 0, -30, 100000); RooRealVar bkg("bkg", "Background", 20, 0, 40000); // Build pdf RooAddPdf sumpdf_float("sumpdf_float", "Generic D sum pdf", RooArgList(cb_float, argus), RooArgList(yld, bkg)); RooDataSet* dset = RooDataSet::read(bkgfile, RooArgList(mbc, ebeam, passed), "", ""); RooPlot* xframe = mbc.frame(); RooDataSet* dset2 = dset->reduce("passed==1"); dset2->plotOn(xframe); // RooFitResult* rv = sumpdf_float.fitTo(*dset2, Extended(kTRUE), Save(kTRUE), // Hesse(kTRUE), Verbose(kTRUE)); RooFitResult* rv = sumpdf_float.fitTo(*dset2, "ermh"); sumpdf_float.paramOn(xframe, dset2); if ((yld.getVal() < 0) && (-yld.getVal()/bkg.getVal() > 0.5)){ yld.setVal(0); bkg.setVal(1); } sumpdf_float.plotOn(xframe); sumpdf_float.plotOn(xframe, Components(RooArgSet(argus)), LineColor(kRed), LineStyle(kDashed)); TCanvas* c1 = new TCanvas("c1","Canvas", 2); xframe->SetTitleOffset(2.2, "Y"); xframe->SetTitleOffset(1.1, "X"); xframe->SetTitle(title); c1->SetLeftMargin(0.17); xframe->Draw(); if ( rv && rv->covQual() != 3){ // fit has failed TText *txt = new TText(); txt->SetTextSize(.08); txt->SetTextAlign(22); txt->SetTextAngle(30); txt->DrawTextNDC(0.5, 0.5, "FAILED"); } c1->Update(); c1->Print(epsfile); c1->Clear(); FILE* table = fopen(txtfile.Data(), "w+"); fprintf(table, "Name\t|| Value\t|| Error\n"); // fprintf(table, "yldsigma\t| %.10f\t| \n", yld.getVal()/yld.getError()); fprintf(table, "entries\t| %.10f\t| \n", dset->numEntries()); fprintf(table, "yld\t| %.10f\t| %.10f\n", yld.getVal(), yld.getError()); // fprintf(table, "ratio\t| %.10f\t| \n", yld.getVal()/dset->numEntries()); // fprintf(table, "ratioerr\t| %.10f\t| \n", yld.getError()/dset->numEntries()); fclose(table); cout << "Saved output as: " << txtfile << endl; rv->Delete(); }
int main(int argc, char *argv[]){ OptionParser(argc,argv); RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR); RooMsgService::instance().setSilentMode(true); system(Form("mkdir -p %s",outdir_.c_str())); vector<string> procs; split(infilenames_,infilenamesStr_,boost::is_any_of(",")); TPython::Exec("import os,imp,re"); const char * env = gSystem->Getenv("CMSSW_BASE") ; std::string globeRt = env; TPython::Exec(Form("buildSMHiggsSignalXSBR = imp.load_source('*', '%s/src/flashggFinalFit/Signal/python/buildSMHiggsSignalXSBR.py')",globeRt.c_str())); TPython::Eval(Form("buildSMHiggsSignalXSBR.Init%dTeV()", 13)); for (unsigned int i =0 ; i<infilenames_.size() ; i++){ int mH =(int) TPython::Eval(Form("int(re.search('_M(.+?)_','%s').group(1))",infilenames_[i].c_str())); double WH_XS = (double)TPython::Eval(Form("buildSMHiggsSignalXSBR.getXS(%d,'%s')",mH,"WH")); double ZH_XS = (double)TPython::Eval(Form("buildSMHiggsSignalXSBR.getXS(%d,'%s')",mH,"ZH")); float tot_XS = WH_XS + ZH_XS; float wFrac= WH_XS /tot_XS ; float zFrac= ZH_XS /tot_XS ; std::cout << "mass "<< mH << " wh fraction "<< WH_XS /tot_XS << ", zh fraction "<< ZH_XS /tot_XS <<std::endl; TFile *infile = TFile::Open(infilenames_[i].c_str()); string outname =(string) TPython::Eval(Form("'%s'.split(\"/\")[-1].replace(\"VH\",\"WH_VH\")",infilenames_[i].c_str())); TFile *outfile = TFile::Open(outname.c_str(),"RECREATE") ; TDirectory* saveDir = outfile->mkdir("tagsDumper"); saveDir->cd(); RooWorkspace *inWS = (RooWorkspace*) infile->Get("tagsDumper/cms_hgg_13TeV"); RooRealVar *intLumi = (RooRealVar*)inWS->var("IntLumi"); RooWorkspace *outWS = new RooWorkspace("cms_hgg_13TeV"); outWS->import(*intLumi); std::list<RooAbsData*> data = (inWS->allData()) ; std::cout <<" [INFO] Reading WS dataset contents: "<< std::endl; for (std::list<RooAbsData*>::const_iterator iterator = data.begin(), end = data.end(); iterator != end; ++iterator ) { RooDataSet *dataset = dynamic_cast<RooDataSet *>( *iterator ); if (dataset) { string zhname =(string) TPython::Eval(Form("'%s'.replace(\"wzh\",\"zh\")",dataset->GetName())); string whname =(string) TPython::Eval(Form("'%s'.replace(\"wzh\",\"wh\")",dataset->GetName())); RooDataSet *datasetZH = (RooDataSet*) dataset->emptyClone(zhname.c_str(),zhname.c_str()); RooDataSet *datasetWH = (RooDataSet*) dataset->emptyClone(whname.c_str(),whname.c_str()); TRandom3 r; r.Rndm(); double x[dataset->numEntries()]; r.RndmArray(dataset->numEntries(),x); for (int j =0; j < dataset->numEntries() ; j++){ if( x[j] < wFrac){ dataset->get(j); datasetWH->add(*(dataset->get(j)),dataset->weight()); } else{ dataset->get(j); datasetZH->add(*(dataset->get(j)),dataset->weight()); } } float w =datasetWH->sumEntries(); float z =datasetZH->sumEntries(); if(verbose_){ std::cout << "Original dataset " << *dataset <<std::endl; std::cout << "WH dataset " << *datasetWH <<std::endl; std::cout << "ZH dataset " << *datasetZH <<std::endl; std::cout << "********************************************" <<std::endl; std::cout << "WH fraction (obs) : WH " << w/(w+z) <<", ZH "<< z/(w+z) << std::endl; std::cout << "WH fraction (exp) : WH " << wFrac <<", ZH "<< zFrac << std::endl; std::cout << "********************************************" <<std::endl; std::cout << "" <<std::endl; std::cout << "" <<std::endl; std::cout << "" <<std::endl; std::cout << "********************************************" <<std::endl; } outWS->import(*datasetWH); outWS->import(*datasetZH); } RooDataHist *datahist = dynamic_cast<RooDataHist *>( *iterator ); if (datahist) { string zhname =(string) TPython::Eval(Form("'%s'.replace(\"wzh\",\"zh\")",datahist->GetName())); string whname =(string) TPython::Eval(Form("'%s'.replace(\"wzh\",\"wh\")",datahist->GetName())); RooDataHist *datahistZH = (RooDataHist*) datahist->emptyClone(zhname.c_str(),zhname.c_str()); RooDataHist *datahistWH = (RooDataHist*) datahist->emptyClone(whname.c_str(),whname.c_str()); TRandom3 r; r.Rndm(); double x[datahist->numEntries()]; r.RndmArray(datahist->numEntries(),x); for (int j =0; j < datahist->numEntries() ; j++){ datahistWH->add(*(datahist->get(j)),datahist->weight()*wFrac); datahistZH->add(*(datahist->get(j)),datahist->weight()*zFrac); } float w =datahistWH->sumEntries(); float z =datahistZH->sumEntries(); if(verbose_){ std::cout << "Original datahist " << *datahist <<std::endl; std::cout << "WH datahist " << *datahistWH <<std::endl; std::cout << "ZH datahist " << *datahistZH <<std::endl; std::cout << "********************************************" <<std::endl; std::cout << "WH fraction (obs) : WH " << w/(w+z) <<", ZH "<< z/(w+z) << std::endl; std::cout << "WH fraction (exp) : WH " << wFrac <<", ZH "<< zFrac << std::endl; std::cout << "********************************************" <<std::endl; std::cout << "" <<std::endl; std::cout << "" <<std::endl; std::cout << "" <<std::endl; std::cout << "********************************************" <<std::endl; } outWS->import(*datahistWH); outWS->import(*datahistZH); } } saveDir->cd(); outWS->Write(); outfile->Close(); infile->Close(); } }
void OneSidedFrequentistUpperLimitWithBands(const char* infile = "", const char* workspaceName = "combined", const char* modelConfigName = "ModelConfig", const char* dataName = "obsData") { double confidenceLevel=0.95; int nPointsToScan = 20; int nToyMC = 200; // ------------------------------------------------------- // First part is just to access a user-defined file // or create the standard example file if it doesn't exist const char* filename = ""; if (!strcmp(infile,"")) { filename = "results/example_combined_GaussExample_model.root"; bool fileExist = !gSystem->AccessPathName(filename); // note opposite return code // if file does not exists generate with histfactory if (!fileExist) { #ifdef _WIN32 cout << "HistFactory file cannot be generated on Windows - exit" << endl; return; #endif // Normally this would be run on the command line cout <<"will run standard hist2workspace example"<<endl; gROOT->ProcessLine(".! prepareHistFactory ."); gROOT->ProcessLine(".! hist2workspace config/example.xml"); cout <<"\n\n---------------------"<<endl; cout <<"Done creating example input"<<endl; cout <<"---------------------\n\n"<<endl; } } else filename = infile; // Try to open the file TFile *file = TFile::Open(filename); // if input file was specified byt not found, quit if(!file ){ cout <<"StandardRooStatsDemoMacro: Input file " << filename << " is not found" << endl; return; } // ------------------------------------------------------- // Now get the data and workspace // get the workspace out of the file RooWorkspace* w = (RooWorkspace*) file->Get(workspaceName); if(!w){ cout <<"workspace not found" << endl; return; } // get the modelConfig out of the file ModelConfig* mc = (ModelConfig*) w->obj(modelConfigName); // get the modelConfig out of the file RooAbsData* data = w->data(dataName); // make sure ingredients are found if(!data || !mc){ w->Print(); cout << "data or ModelConfig was not found" <<endl; return; } // ------------------------------------------------------- // Now get the POI for convenience // you may want to adjust the range of your POI RooRealVar* firstPOI = (RooRealVar*) mc->GetParametersOfInterest()->first(); /* firstPOI->setMin(0);*/ /* firstPOI->setMax(10);*/ // -------------------------------------------- // Create and use the FeldmanCousins tool // to find and plot the 95% confidence interval // on the parameter of interest as specified // in the model config // REMEMBER, we will change the test statistic // so this is NOT a Feldman-Cousins interval FeldmanCousins fc(*data,*mc); fc.SetConfidenceLevel(confidenceLevel); /* fc.AdditionalNToysFactor(0.25); // degrade/improve sampling that defines confidence belt*/ /* fc.UseAdaptiveSampling(true); // speed it up a bit, don't use for expected limits*/ fc.SetNBins(nPointsToScan); // set how many points per parameter of interest to scan fc.CreateConfBelt(true); // save the information in the belt for plotting // ------------------------------------------------------- // Feldman-Cousins is a unified limit by definition // but the tool takes care of a few things for us like which values // of the nuisance parameters should be used to generate toys. // so let's just change the test statistic and realize this is // no longer "Feldman-Cousins" but is a fully frequentist Neyman-Construction. /* ProfileLikelihoodTestStatModified onesided(*mc->GetPdf());*/ /* fc.GetTestStatSampler()->SetTestStatistic(&onesided);*/ /* ((ToyMCSampler*) fc.GetTestStatSampler())->SetGenerateBinned(true); */ ToyMCSampler* toymcsampler = (ToyMCSampler*) fc.GetTestStatSampler(); ProfileLikelihoodTestStat* testStat = dynamic_cast<ProfileLikelihoodTestStat*>(toymcsampler->GetTestStatistic()); testStat->SetOneSided(true); // Since this tool needs to throw toy MC the PDF needs to be // extended or the tool needs to know how many entries in a dataset // per pseudo experiment. // In the 'number counting form' where the entries in the dataset // are counts, and not values of discriminating variables, the // datasets typically only have one entry and the PDF is not // extended. if(!mc->GetPdf()->canBeExtended()){ if(data->numEntries()==1) fc.FluctuateNumDataEntries(false); else cout <<"Not sure what to do about this model" <<endl; } // We can use PROOF to speed things along in parallel // However, the test statistic has to be installed on the workers // so either turn off PROOF or include the modified test statistic // in your `$ROOTSYS/roofit/roostats/inc` directory, // add the additional line to the LinkDef.h file, // and recompile root. if (useProof) { ProofConfig pc(*w, nworkers, "", false); toymcsampler->SetProofConfig(&pc); // enable proof } if(mc->GetGlobalObservables()){ cout << "will use global observables for unconditional ensemble"<<endl; mc->GetGlobalObservables()->Print(); toymcsampler->SetGlobalObservables(*mc->GetGlobalObservables()); } // Now get the interval PointSetInterval* interval = fc.GetInterval(); ConfidenceBelt* belt = fc.GetConfidenceBelt(); // print out the interval on the first Parameter of Interest cout << "\n95% interval on " <<firstPOI->GetName()<<" is : ["<< interval->LowerLimit(*firstPOI) << ", "<< interval->UpperLimit(*firstPOI) <<"] "<<endl; // get observed UL and value of test statistic evaluated there RooArgSet tmpPOI(*firstPOI); double observedUL = interval->UpperLimit(*firstPOI); firstPOI->setVal(observedUL); double obsTSatObsUL = fc.GetTestStatSampler()->EvaluateTestStatistic(*data,tmpPOI); // Ask the calculator which points were scanned RooDataSet* parameterScan = (RooDataSet*) fc.GetPointsToScan(); RooArgSet* tmpPoint; // make a histogram of parameter vs. threshold TH1F* histOfThresholds = new TH1F("histOfThresholds","", parameterScan->numEntries(), firstPOI->getMin(), firstPOI->getMax()); histOfThresholds->GetXaxis()->SetTitle(firstPOI->GetName()); histOfThresholds->GetYaxis()->SetTitle("Threshold"); // loop through the points that were tested and ask confidence belt // what the upper/lower thresholds were. // For FeldmanCousins, the lower cut off is always 0 for(Int_t i=0; i<parameterScan->numEntries(); ++i){ tmpPoint = (RooArgSet*) parameterScan->get(i)->clone("temp"); //cout <<"get threshold"<<endl; double arMax = belt->GetAcceptanceRegionMax(*tmpPoint); double poiVal = tmpPoint->getRealValue(firstPOI->GetName()) ; histOfThresholds->Fill(poiVal,arMax); } TCanvas* c1 = new TCanvas(); c1->Divide(2); c1->cd(1); histOfThresholds->SetMinimum(0); histOfThresholds->Draw(); c1->cd(2); // ------------------------------------------------------- // Now we generate the expected bands and power-constraint // First: find parameter point for mu=0, with conditional MLEs for nuisance parameters RooAbsReal* nll = mc->GetPdf()->createNLL(*data); RooAbsReal* profile = nll->createProfile(*mc->GetParametersOfInterest()); firstPOI->setVal(0.); profile->getVal(); // this will do fit and set nuisance parameters to profiled values RooArgSet* poiAndNuisance = new RooArgSet(); if(mc->GetNuisanceParameters()) poiAndNuisance->add(*mc->GetNuisanceParameters()); poiAndNuisance->add(*mc->GetParametersOfInterest()); w->saveSnapshot("paramsToGenerateData",*poiAndNuisance); RooArgSet* paramsToGenerateData = (RooArgSet*) poiAndNuisance->snapshot(); cout << "\nWill use these parameter points to generate pseudo data for bkg only" << endl; paramsToGenerateData->Print("v"); RooArgSet unconditionalObs; unconditionalObs.add(*mc->GetObservables()); unconditionalObs.add(*mc->GetGlobalObservables()); // comment this out for the original conditional ensemble double CLb=0; double CLbinclusive=0; // Now we generate background only and find distribution of upper limits TH1F* histOfUL = new TH1F("histOfUL","",100,0,firstPOI->getMax()); histOfUL->GetXaxis()->SetTitle("Upper Limit (background only)"); histOfUL->GetYaxis()->SetTitle("Entries"); for(int imc=0; imc<nToyMC; ++imc){ // set parameters back to values for generating pseudo data // cout << "\n get current nuis, set vals, print again" << endl; w->loadSnapshot("paramsToGenerateData"); // poiAndNuisance->Print("v"); RooDataSet* toyData = 0; // now generate a toy dataset if(!mc->GetPdf()->canBeExtended()){ if(data->numEntries()==1) toyData = mc->GetPdf()->generate(*mc->GetObservables(),1); else cout <<"Not sure what to do about this model" <<endl; } else{ // cout << "generating extended dataset"<<endl; toyData = mc->GetPdf()->generate(*mc->GetObservables(),Extended()); } // generate global observables // need to be careful for simpdf // RooDataSet* globalData = mc->GetPdf()->generate(*mc->GetGlobalObservables(),1); RooSimultaneous* simPdf = dynamic_cast<RooSimultaneous*>(mc->GetPdf()); if(!simPdf){ RooDataSet *one = mc->GetPdf()->generate(*mc->GetGlobalObservables(), 1); const RooArgSet *values = one->get(); RooArgSet *allVars = mc->GetPdf()->getVariables(); *allVars = *values; delete allVars; delete values; delete one; } else { //try fix for sim pdf TIterator* iter = simPdf->indexCat().typeIterator() ; RooCatType* tt = NULL; while((tt=(RooCatType*) iter->Next())) { // Get pdf associated with state from simpdf RooAbsPdf* pdftmp = simPdf->getPdf(tt->GetName()) ; // Generate only global variables defined by the pdf associated with this state RooArgSet* globtmp = pdftmp->getObservables(*mc->GetGlobalObservables()) ; RooDataSet* tmp = pdftmp->generate(*globtmp,1) ; // Transfer values to output placeholder *globtmp = *tmp->get(0) ; // Cleanup delete globtmp ; delete tmp ; } } // globalData->Print("v"); // unconditionalObs = *globalData->get(); // mc->GetGlobalObservables()->Print("v"); // delete globalData; // cout << "toy data = " << endl; // toyData->get()->Print("v"); // get test stat at observed UL in observed data firstPOI->setVal(observedUL); double toyTSatObsUL = fc.GetTestStatSampler()->EvaluateTestStatistic(*toyData,tmpPOI); // toyData->get()->Print("v"); // cout <<"obsTSatObsUL " <<obsTSatObsUL << "toyTS " << toyTSatObsUL << endl; if(obsTSatObsUL < toyTSatObsUL) // not sure about <= part yet CLb+= (1.)/nToyMC; if(obsTSatObsUL <= toyTSatObsUL) // not sure about <= part yet CLbinclusive+= (1.)/nToyMC; // loop over points in belt to find upper limit for this toy data double thisUL = 0; for(Int_t i=0; i<parameterScan->numEntries(); ++i){ tmpPoint = (RooArgSet*) parameterScan->get(i)->clone("temp"); double arMax = belt->GetAcceptanceRegionMax(*tmpPoint); firstPOI->setVal( tmpPoint->getRealValue(firstPOI->GetName()) ); // double thisTS = profile->getVal(); double thisTS = fc.GetTestStatSampler()->EvaluateTestStatistic(*toyData,tmpPOI); // cout << "poi = " << firstPOI->getVal() // << " max is " << arMax << " this profile = " << thisTS << endl; // cout << "thisTS = " << thisTS<<endl; if(thisTS<=arMax){ thisUL = firstPOI->getVal(); } else{ break; } } /* // loop over points in belt to find upper limit for this toy data double thisUL = 0; for(Int_t i=0; i<histOfThresholds->GetNbinsX(); ++i){ tmpPoint = (RooArgSet*) parameterScan->get(i)->clone("temp"); cout <<"---------------- "<<i<<endl; tmpPoint->Print("v"); cout << "from hist " << histOfThresholds->GetBinCenter(i+1) <<endl; double arMax = histOfThresholds->GetBinContent(i+1); // cout << " threhold from Hist = aMax " << arMax<<endl; // double arMax2 = belt->GetAcceptanceRegionMax(*tmpPoint); // cout << "from scan arMax2 = "<< arMax2 << endl; // not the same due to TH1F not TH1D // cout << "scan - hist" << arMax2-arMax << endl; firstPOI->setVal( histOfThresholds->GetBinCenter(i+1)); // double thisTS = profile->getVal(); double thisTS = fc.GetTestStatSampler()->EvaluateTestStatistic(*toyData,tmpPOI); // cout << "poi = " << firstPOI->getVal() // << " max is " << arMax << " this profile = " << thisTS << endl; // cout << "thisTS = " << thisTS<<endl; // NOTE: need to add a small epsilon term for single precision vs. double precision if(thisTS<=arMax + 1e-7){ thisUL = firstPOI->getVal(); } else{ break; } } */ histOfUL->Fill(thisUL); // for few events, data is often the same, and UL is often the same // cout << "thisUL = " << thisUL<<endl; delete toyData; } histOfUL->Draw(); c1->SaveAs("one-sided_upper_limit_output.pdf"); // if you want to see a plot of the sampling distribution for a particular scan point: /* SamplingDistPlot sampPlot; int indexInScan = 0; tmpPoint = (RooArgSet*) parameterScan->get(indexInScan)->clone("temp"); firstPOI->setVal( tmpPoint->getRealValue(firstPOI->GetName()) ); toymcsampler->SetParametersForTestStat(tmpPOI); SamplingDistribution* samp = toymcsampler->GetSamplingDistribution(*tmpPoint); sampPlot.AddSamplingDistribution(samp); sampPlot.Draw(); */ // Now find bands and power constraint Double_t* bins = histOfUL->GetIntegral(); TH1F* cumulative = (TH1F*) histOfUL->Clone("cumulative"); cumulative->SetContent(bins); double band2sigDown, band1sigDown, bandMedian, band1sigUp,band2sigUp; for(int i=1; i<=cumulative->GetNbinsX(); ++i){ if(bins[i]<RooStats::SignificanceToPValue(2)) band2sigDown=cumulative->GetBinCenter(i); if(bins[i]<RooStats::SignificanceToPValue(1)) band1sigDown=cumulative->GetBinCenter(i); if(bins[i]<0.5) bandMedian=cumulative->GetBinCenter(i); if(bins[i]<RooStats::SignificanceToPValue(-1)) band1sigUp=cumulative->GetBinCenter(i); if(bins[i]<RooStats::SignificanceToPValue(-2)) band2sigUp=cumulative->GetBinCenter(i); } cout << "-2 sigma band " << band2sigDown << endl; cout << "-1 sigma band " << band1sigDown << " [Power Constraint)]" << endl; cout << "median of band " << bandMedian << endl; cout << "+1 sigma band " << band1sigUp << endl; cout << "+2 sigma band " << band2sigUp << endl; // print out the interval on the first Parameter of Interest cout << "\nobserved 95% upper-limit "<< interval->UpperLimit(*firstPOI) <<endl; cout << "CLb strict [P(toy>obs|0)] for observed 95% upper-limit "<< CLb <<endl; cout << "CLb inclusive [P(toy>=obs|0)] for observed 95% upper-limit "<< CLbinclusive <<endl; delete profile; delete nll; }
void embeddedToysWithBackgDetEffects_1DKD(int nEvts=600, int nToys=3000, sample mySample = kScalar_fa3p5, bool bkg, bool sigFloating, int counter){ RooRealVar* kd = new RooRealVar("psMELA","psMELA",0,1); kd->setBins(1000); RooPlot* kdframe1 = kd->frame(); // 0- template TFile f1("KDdistribution_ps_analytical_detEff.root", "READ"); TH1F *h_KD_ps = (TH1F*)f1.Get("h_KD"); h_KD_ps->SetName("h_KD_ps"); RooDataHist rdh_KD_ps("rdh_KD_ps","rdh_KD_ps",RooArgList(*kd),h_KD_ps); RooHistPdf pdf_KD_ps("pdf_KD_ps","pdf_KD_ps",RooArgList(*kd),rdh_KD_ps); // 0+ template TFile f2("KDdistribution_sm_analytical_detEff.root", "READ"); TH1F *h_KD_sm = (TH1F*)f2.Get("h_KD"); h_KD_sm->SetName("h_KD_sm"); RooDataHist rdh_KD_sm("rdh_KD_sm","rdh_KD_sm",RooArgList(*kd),h_KD_sm); RooHistPdf pdf_KD_sm("pdf_KD_sm","pdf_KD_sm",RooArgList(*kd),rdh_KD_sm); // backg template TFile f3("KDdistribution_bkg_analytical_detEff.root", "READ"); TH1F *h_KD_bkg = (TH1F*)f3.Get("h_KD"); h_KD_bkg->SetName("h_KD_bkg"); RooDataHist rdh_KD_bkg("rdh_KD_bkg","rdh_KD_bkg",RooArgList(*kd),h_KD_bkg); RooHistPdf pdf_KD_bkg("pdf_KD_bkg","pdf_KD_bkg",RooArgList(*kd),rdh_KD_bkg); //Define signal model with 0+, 0- mixture RooRealVar rrv_fa3("fa3","fa3",0.5,0.,1.); //free parameter of the model RooFormulaVar rfv_fa3Obs("fa3obs","1/ (1 + (1/@0 - 1)*0.99433)",RooArgList(rrv_fa3)); RooAddPdf modelSignal("modelSignal","ps+sm",pdf_KD_ps,pdf_KD_sm,rfv_fa3Obs); rrv_fa3.setConstant(kFALSE); //Define signal+bakground model RooRealVar rrv_BoverTOT("BoverTOT","BoverTOT",1/(3.75+1),0.,10.); RooAddPdf model("model","background+modelSignal",pdf_KD_bkg,modelSignal,rrv_BoverTOT); if(sigFloating) rrv_BoverTOT.setConstant(kFALSE); else rrv_BoverTOT.setConstant(kTRUE); //Set the values of free parameters to compute pulls double fa3Val=-99; if (mySample == kScalar_fa3p0) fa3Val=0.; else if (mySample == kScalar_fa3p1) fa3Val=0.1; else if (mySample == kScalar_fa3p5 || mySample == kScalar_fa3p5phia390) fa3Val=0.5; else if (mySample == kScalar_fa3p25) fa3Val=0.25; else{ cout<<"fa3Val not correct!"<<endl; return 0; } double sigFracVal=1 - 1/(3.75+1); //Plot the models TCanvas* c = new TCanvas("modelPlot_detBkg","modelPlot_detBkg",400,400); rdh_KD_ps.plotOn(kdframe1,LineColor(kBlack),MarkerColor(kBlack)); pdf_KD_ps.plotOn(kdframe1,LineColor(kBlack),RooFit::Name("pseudo")); //rdh_KD_sm.plotOn(kdframe1,LineColor(kBlue),MarkColor(kBlue)); pdf_KD_sm.plotOn(kdframe1,LineColor(kBlue),RooFit::Name("SM")); //rdh_KD_bkg.plotOn(kdframe1,LineColor(kGreen),LineColor(kGreen)); pdf_KD_bkg.plotOn(kdframe1,LineColor(kGreen),RooFit::Name("bkg")); modelSignal.plotOn(kdframe1,LineColor(kRed),RooFit::Name("signal_fa3p5")); model.plotOn(kdframe1,LineColor(kOrange),RooFit::Name("signal+background")); TLegend *leg = new TLegend (0.7,0.6,0.95,0.8); leg->AddEntry(kdframe1->findObject("pseudo"),"0-","L"); leg->AddEntry(kdframe1->findObject("SM"),"0+","L"); leg->AddEntry(kdframe1->findObject("bkg"),"bkg","L"); leg->AddEntry(kdframe1->findObject("signal_fa3p5"),"signal fa3=0.5","L"); leg->AddEntry(kdframe1->findObject("signal+background"),"signal + bkg","L"); kdframe1->Draw(); leg->SetFillColor(kWhite); leg->Draw("same"); c->SaveAs("modelPlot_detBkg.eps"); c->SaveAs("modelPlot_detBkg.png"); //Load the trees into the datasets TChain* myChain = new TChain("SelectedTree"); myChain->Add(inputFileNames[mySample]); if(!myChain || myChain->GetEntries()<=0) { cout<<"error in the tree"<<endl; return 0; } RooDataSet* data = new RooDataSet("data","data",myChain,RooArgSet(*kd),""); TChain* myChain_bkg = new TChain("SelectedTree"); myChain_bkg->Add("samples/analyticalpsMELA/withResolution/pwgevents_mllCut10_smeared_withDiscriminants_2e2mu_cutDetector.root"); myChain_bkg->Add("samples/analyticalpsMELA/withResolution/pwgevents_mllCut4_wResolution_withDiscriminants_cutDetector.root"); if(!myChain_bkg || myChain_bkg->GetEntries()<=0) { cout<<"error in the tree"<<endl; return 0; } RooDataSet* data_bkg = new RooDataSet("data_bkg","data_bkg",myChain_bkg,RooArgSet(*kd),""); cout << "Number of events in data sig: " << data->numEntries() << endl; cout << "Number of events in data bkg: " << data_bkg->numEntries() << endl; // Initialize tree to save toys to TTree* results = new TTree("results","toy results"); double fa3,fa3Error, fa3Pull; double sigFrac,sigFracError, sigFracPull; double significance; results->Branch("fa3",&fa3,"fa3/D"); results->Branch("fa3Error",&fa3Error,"fa3Error/D"); results->Branch("fa3Pull",&fa3Pull,"fa3Pull/D"); results->Branch("sigFrac",&sigFrac,"sigFrac/D"); results->Branch("sigFracError",&sigFracError,"sigFracError/D"); results->Branch("sigFracPull",&sigFracPull,"sigFracPull/D"); results->Branch("significance",&significance,"significance/D"); //--------------------------------- RooDataSet* toyData; RooDataSet* toyData_bkgOnly; int embedTracker=nEvts*counter; int embedTracker_bkg=TMath::Ceil(nEvts/3.75*counter); RooArgSet *tempEvent; RooFitResult *toyfitresults; RooFitResult *toyfitresults_sigBkg; RooFitResult *toyfitresults_bkgOnly; RooRealVar *r_fa3; RooRealVar *r_sigFrac; for(int i = 0 ; i<nToys ; i++){ cout <<i<<"<-----------------------------"<<endl; //if(toyData) delete toyData; toyData = new RooDataSet("toyData","toyData",RooArgSet(*kd)); toyData_bkgOnly = new RooDataSet("toyData_bkgOnly","toyData_bkgOnly",RooArgSet(*kd)); if(nEvts+embedTracker > data->sumEntries()){ cout << "Playground::generate() - ERROR!!! Playground::data does not have enough events to fill toy!!!! bye :) " << endl; toyData = NULL; abort(); return 0; } if(nEvts+embedTracker_bkg > data_bkg->sumEntries()){ cout << "Playground::generate() - ERROR!!! Playground::data does not have enough events to fill toy!!!! bye :) " << endl; toyData = NULL; abort(); return 0; } for(int iEvent=0; iEvent<nEvts; iEvent++){ if(iEvent==1) cout << "generating event: " << iEvent << " embedTracker: " << embedTracker << endl; tempEvent = (RooArgSet*) data->get(embedTracker); toyData->add(*tempEvent); embedTracker++; } if(bkg){ for(int iEvent=0; iEvent<nEvts/3.75; iEvent++){ if(iEvent==1) cout << "generating bkg event: " << iEvent << " embedTracker bkg: " << embedTracker_bkg << endl; tempEvent = (RooArgSet*) data_bkg->get(embedTracker_bkg); toyData->add(*tempEvent); toyData_bkgOnly->add(*tempEvent); embedTracker_bkg++; } } if(bkg) toyfitresults =model.fitTo(*toyData,Save()); else toyfitresults =modelSignal.fitTo(*toyData,Save()); //cout<<toyfitresults<<endl; r_fa3 = (RooRealVar *) toyfitresults->floatParsFinal().find("fa3"); fa3 = r_fa3->getVal(); fa3Error = r_fa3->getError(); fa3Pull = (r_fa3->getVal() - fa3Val) / r_fa3->getError(); if(sigFloating){ r_sigFrac = (RooRealVar *) toyfitresults->floatParsFinal().find("BoverTOT"); sigFrac = 1-r_sigFrac->getVal(); sigFracError = r_sigFrac->getError(); sigFracPull = (1-r_sigFrac->getVal() - sigFracVal) / r_sigFrac->getError(); } // fill TTree results->Fill(); } char nEvtsString[100]; sprintf(nEvtsString,"_%iEvts_%iiter",nEvts, counter); // write tree to output file (ouputFileName set at top) TFile *outputFile = new TFile("embeddedToys1DKD_fa3Corr_WithBackgDetEffects_"+sampleName[mySample]+nEvtsString+".root","RECREATE"); results->Write(); outputFile->Close(); }
void StandardFeldmanCousinsDemo(const char* infile = "", const char* workspaceName = "combined", const char* modelConfigName = "ModelConfig", const char* dataName = "obsData"){ // ------------------------------------------------------- // First part is just to access a user-defined file // or create the standard example file if it doesn't exist const char* filename = ""; if (!strcmp(infile,"")) { filename = "results/example_combined_GaussExample_model.root"; bool fileExist = !gSystem->AccessPathName(filename); // note opposite return code // if file does not exists generate with histfactory if (!fileExist) { #ifdef _WIN32 cout << "HistFactory file cannot be generated on Windows - exit" << endl; return; #endif // Normally this would be run on the command line cout <<"will run standard hist2workspace example"<<endl; gROOT->ProcessLine(".! prepareHistFactory ."); gROOT->ProcessLine(".! hist2workspace config/example.xml"); cout <<"\n\n---------------------"<<endl; cout <<"Done creating example input"<<endl; cout <<"---------------------\n\n"<<endl; } } else filename = infile; // Try to open the file TFile *file = TFile::Open(filename); // if input file was specified byt not found, quit if(!file ){ cout <<"StandardRooStatsDemoMacro: Input file " << filename << " is not found" << endl; return; } // ------------------------------------------------------- // Tutorial starts here // ------------------------------------------------------- // get the workspace out of the file RooWorkspace* w = (RooWorkspace*) file->Get(workspaceName); if(!w){ cout <<"workspace not found" << endl; return; } // get the modelConfig out of the file ModelConfig* mc = (ModelConfig*) w->obj(modelConfigName); // get the modelConfig out of the file RooAbsData* data = w->data(dataName); // make sure ingredients are found if(!data || !mc){ w->Print(); cout << "data or ModelConfig was not found" <<endl; return; } // ------------------------------------------------------- // create and use the FeldmanCousins tool // to find and plot the 95% confidence interval // on the parameter of interest as specified // in the model config FeldmanCousins fc(*data,*mc); fc.SetConfidenceLevel(0.95); // 95% interval //fc.AdditionalNToysFactor(0.1); // to speed up the result fc.UseAdaptiveSampling(true); // speed it up a bit fc.SetNBins(10); // set how many points per parameter of interest to scan fc.CreateConfBelt(true); // save the information in the belt for plotting // Since this tool needs to throw toy MC the PDF needs to be // extended or the tool needs to know how many entries in a dataset // per pseudo experiment. // In the 'number counting form' where the entries in the dataset // are counts, and not values of discriminating variables, the // datasets typically only have one entry and the PDF is not // extended. if(!mc->GetPdf()->canBeExtended()){ if(data->numEntries()==1) fc.FluctuateNumDataEntries(false); else cout <<"Not sure what to do about this model" <<endl; } // We can use PROOF to speed things along in parallel // ProofConfig pc(*w, 1, "workers=4", kFALSE); // ToyMCSampler* toymcsampler = (ToyMCSampler*) fc.GetTestStatSampler(); // toymcsampler->SetProofConfig(&pc); // enable proof // Now get the interval PointSetInterval* interval = fc.GetInterval(); ConfidenceBelt* belt = fc.GetConfidenceBelt(); // print out the iterval on the first Parameter of Interest RooRealVar* firstPOI = (RooRealVar*) mc->GetParametersOfInterest()->first(); cout << "\n95% interval on " <<firstPOI->GetName()<<" is : ["<< interval->LowerLimit(*firstPOI) << ", "<< interval->UpperLimit(*firstPOI) <<"] "<<endl; // --------------------------------------------- // No nice plots yet, so plot the belt by hand // Ask the calculator which points were scanned RooDataSet* parameterScan = (RooDataSet*) fc.GetPointsToScan(); RooArgSet* tmpPoint; // make a histogram of parameter vs. threshold TH1F* histOfThresholds = new TH1F("histOfThresholds","", parameterScan->numEntries(), firstPOI->getMin(), firstPOI->getMax()); // loop through the points that were tested and ask confidence belt // what the upper/lower thresholds were. // For FeldmanCousins, the lower cut off is always 0 for(Int_t i=0; i<parameterScan->numEntries(); ++i){ tmpPoint = (RooArgSet*) parameterScan->get(i)->clone("temp"); double arMax = belt->GetAcceptanceRegionMax(*tmpPoint); double arMin = belt->GetAcceptanceRegionMax(*tmpPoint); double poiVal = tmpPoint->getRealValue(firstPOI->GetName()) ; histOfThresholds->Fill(poiVal,arMax); } histOfThresholds->SetMinimum(0); histOfThresholds->Draw(); }
void makejpsifit(string inputFilename, string outFilename, Int_t ptBin, Int_t etaBin, double minMass, double maxMass, double mean_bw, double gamma_bw, double cutoff_cb, double power_cb, const char* plotOpt, const int nbins, Int_t isMC) { TStyle *mystyle = RooHZZStyle("ZZ"); mystyle->cd(); //Create Data Set RooRealVar mass("zmass","m(e^{+}e^{-})",minMass,maxMass,"GeV/c^{2}"); // Reading everything from root tree instead TFile *tfile = TFile::Open(inputFilename.c_str()); TTree *ttree = (TTree*)tfile->Get("zeetree/probe_tree"); hzztree *zeeTree = new hzztree(ttree); RooArgSet zMassArgSet(mass); RooDataSet* data = new RooDataSet("data", "ntuple parameters", zMassArgSet); for (int i = 0; i < zeeTree->fChain->GetEntries(); i++) { if(i%100000==0) cout << "Processing Event " << i << endl; zeeTree->fChain->GetEntry(i); //************************************************************************* //Electron Selection //************************************************************************* // already passed for this tree //************************************************************************* //Compute electron four vector; //************************************************************************* double ele1pt = zeeTree->l1pt; double ele2pt = zeeTree->l2pt; double ELECTRONMASS = 0.51e-3; TLorentzVector ele1FourVector; ele1FourVector.SetPtEtaPhiM(zeeTree->l1pt, zeeTree->l1eta, zeeTree->l1phi, ELECTRONMASS); TLorentzVector ele2FourVector; ele2FourVector.SetPtEtaPhiM(zeeTree->l2pt, zeeTree->l2eta, zeeTree->l2phi, ELECTRONMASS); //************************************************************************* //pt and eta cuts on electron //************************************************************************* if (! (ele1pt > 7 && ele2pt > 7 && fabs( zeeTree->l1eta) < 2.5 && fabs( zeeTree->l2eta) < 2.5 )) continue; //************************************************************************* //pt bins and eta bins //************************************************************************* Int_t Ele1PtBin = -1; Int_t Ele1EtaBin = -1; Int_t Ele2PtBin = -1; Int_t Ele2EtaBin = -1; if (ele1pt > 7 && ele1pt < 10) Ele1PtBin = 0; else if (ele1pt < 20) Ele1PtBin = 1; else Ele1PtBin = 2; if (ele2pt > 7 && ele2pt < 10) Ele2PtBin = 0; else if (ele2pt < 20) Ele2PtBin = 1; else Ele2PtBin = 2; if (fabs(zeeTree->l1sceta) < 1.479) Ele1EtaBin = 0; else Ele1EtaBin = 1; if (fabs(zeeTree->l2sceta) < 1.479) Ele2EtaBin = 0; else Ele2EtaBin = 1; if (!(Ele1PtBin == ptBin || Ele2PtBin == ptBin)) continue; if (!(Ele1EtaBin == etaBin && Ele2EtaBin == etaBin)) continue; //************************************************************************* // restrict range of mass //************************************************************************* double zMass = (ele1FourVector+ele2FourVector).M(); if (zMass < minMass || zMass > maxMass) continue; //************************************************************************* //set mass variable //************************************************************************* zMassArgSet.setRealValue("zmass", zMass); data->add(zMassArgSet); } // do binned fit to gain time... mass.setBins(nbins); RooDataHist *bdata = new RooDataHist("data_binned","data_binned", zMassArgSet, *data); cout << "dataset size: " << data->numEntries() << endl; // // Closing file // treeFile->Close(); //====================== Parameters=========================== //Crystal Ball parameters // RooRealVar cbBias ("#Deltam_{CB}", "CB Bias", -.01, -10, 10, "GeV/c^{2}"); // RooRealVar cbSigma("sigma_{CB}", "CB Width", 1.7, 0.8, 5.0, "GeV/c^{2}"); // RooRealVar cbCut ("a_{CB}","CB Cut", 1.05, 1.0, 3.0); // RooRealVar cbPower("n_{CB}","CB Order", 2.45, 0.1, 20.0); RooRealVar cbBias ("#Deltam_{CB}", "CB Bias", -.01, -10, 10, "GeV/c^{2}"); RooRealVar cbSigma("#sigma_{CB}", "CB Width", 1.5, 0.01, 5.0, "GeV/c^{2}"); RooRealVar cbCut ("a_{CB}","CB Cut", 1.0, 1.0, 3.0); RooRealVar cbPower("n_{CB}","CB Order", 2.5, 0.1, 20.0); cbCut.setVal(cutoff_cb); cbPower.setVal(power_cb); // Just checking //cbCut.Print(); //cbPower.Print(); //Breit_Wigner parameters RooRealVar bwMean("m_{JPsi}","BW Mean", 3.096916, "GeV/c^{2}"); bwMean.setVal(mean_bw); RooRealVar bwWidth("#Gamma_{JPsi}", "BW Width", 92.9e-6, "GeV/c^{2}"); bwWidth.setVal(gamma_bw); // Fix the Breit-Wigner parameters to PDG values bwMean.setConstant(kTRUE); bwWidth.setConstant(kTRUE); // Exponential Background parameters RooRealVar expRate("#lambda_{exp}", "Exponential Rate", -0.064, -1, 1); RooRealVar c0("c_{0}", "c0", 1., 0., 50.); //Number of Signal and Background events RooRealVar nsig("N_{S}", "# signal events", 524, 0.1, 10000000000.); RooRealVar nbkg("N_{B}", "# background events", 43, 1., 10000000.); //============================ P.D.F.s============================= // Mass signal for two decay electrons p.d.f. RooBreitWigner bw("bw", "bw", mass, bwMean, bwWidth); RooCBShape cball("cball", "Crystal Ball", mass, cbBias, cbSigma, cbCut, cbPower); RooFFTConvPdf BWxCB("BWxCB", "bw X crystal ball", mass, bw, cball); // Mass background p.d.f. RooExponential bg("bg", "exp. background", mass, expRate); // Mass model for signal electrons p.d.f. RooAddPdf model("model", "signal", RooArgList(BWxCB), RooArgList(nsig)); TStopwatch t ; t.Start() ; double fitmin, fitmax; if(isMC) { fitmin = (etaBin==0) ? 3.00 : 2.7; fitmax = (etaBin==0) ? 3.20 : 3.4; } else { fitmin = (etaBin==0) ? ( (ptBin>=2) ? 3.01 : 3.02 ) : 2.7; fitmax = (etaBin==0) ? ( (ptBin==3) ? 3.23 : 3.22 ) : 3.4; } RooFitResult *fitres = model.fitTo(*bdata,Range(fitmin,fitmax),Hesse(1),Minos(1),Timer(1),Save(1)); fitres->SetName("fitres"); t.Print() ; TCanvas* c = new TCanvas("c","Unbinned Invariant Mass Fit", 0,0,800,600); //========================== Plotting ============================ //Create a frame RooPlot* plot = mass.frame(Range(minMass,maxMass),Bins(nbins)); // Add data and model to canvas int col = (isMC ? kAzure+4 : kGreen+1); data->plotOn(plot); model.plotOn(plot,LineColor(col)); data->plotOn(plot); model.paramOn(plot, Format(plotOpt, AutoPrecision(1)), Parameters(RooArgSet(cbBias, cbSigma, cbCut, cbPower, bwMean, bwWidth, expRate, nsig, nbkg)), Layout(0.15,0.45,0.80)); plot->getAttText()->SetTextSize(.03); plot->SetTitle(""); plot->Draw(); // Print Fit Values TLatex *tex = new TLatex(); tex->SetNDC(); tex->SetTextSize(.1); tex->SetTextFont(132); // tex->Draw(); tex->SetTextSize(0.057); if(isMC) tex->DrawLatex(0.65, 0.75, "J/#psi #rightarrow e^{+}e^{-} MC"); else tex->DrawLatex(0.65, 0.75, "J/#psi #rightarrow e^{+}e^{-} data"); tex->SetTextSize(0.030); tex->DrawLatex(0.645, 0.65, Form("BW Mean = %.2f GeV/c^{2}", bwMean.getVal())); tex->DrawLatex(0.645, 0.60, Form("BW #sigma = %.2f GeV/c^{2}", bwWidth.getVal())); c->Update(); c->SaveAs((outFilename + ".pdf").c_str()); c->SaveAs((outFilename + ".png").c_str()); // tablefile << Form(Outfile + "& $ %f $ & $ %f $ & $ %f $\\ \hline",cbBias.getVal(), cbSigma.getVal(), cbCut.getVal()); // Output workspace with model and data RooWorkspace *w = new RooWorkspace("JPsieeMassScaleAndResolutionFit"); w->import(model); w->import(*bdata); w->writeToFile((outFilename + ".root").c_str()); TFile *tfileo = TFile::Open((outFilename + ".root").c_str(),"update"); fitres->Write(); tfileo->Close(); }
void trig_eta_P() { TCanvas *myCan=new TCanvas("myCan","myCan"); myCan->SetGrid(); /************************ TFile *f_RD= new TFile("TnP_Z_Trigger_RDpt.root","read"); RooDataSet *dataset = (RooDataSet*)f_RD->Get("tpTree/Track_To_TightCombRelIso_Mu15_eta2p1_pt/fit_eff"); cout<<"ntry: "<<dataset->numEntries()<<endl; double X[11],XerrL[11],XerrH[11],Y[11],YerrLo[11],YerrHi[11]; for(int i(0); i<dataset->numEntries();i++) { const RooArgSet &point=*dataset->get(i); RooRealVar &pt=point["pt"],&eff = point["efficiency"]; X[i]=pt.getVal(); XerrL[i]=-pt.getAsymErrorLo(); XerrH[i]=pt.getAsymErrorHi(); Y[i]=eff.getVal(); YerrLo[i]=-eff.getAsymErrorLo(); YerrHi[i]=eff.getAsymErrorHi(); } gr=new TGraphAsymmErrors(11,X,Y,XerrL,XerrH,YerrLo,YerrHi); gr->Draw("AP"); ***************************/ ///* TFile *f_MC= new TFile("../efficiency-mc-WptCutToHLT_eta_P.root","read"); RooDataSet *datasetMC = (RooDataSet*)f_MC->Get("WptCutToHLT/efficiency/cnt_eff"); //RooDataSet *datasetMC = (RooDataSet*)f_MC->Get("tpTree/Track_with_TightCombRelIso_to_Mu15_eta2p1_pt/fit_eff"); cout<<"ntry: "<<datasetMC->numEntries()<<endl; double XMC[binSize],XMCerrL[binSize],XMCerrH[binSize],YMC[binSize],YMCerrLo[binSize],YMCerrHi[binSize]; for(int i(0); i<datasetMC->numEntries();i++) { const RooArgSet &pointMC=*datasetMC->get(i); RooRealVar &ptMC=pointMC["probe_sc_eta"],&effMC = pointMC["efficiency"]; XMC[i]=ptMC.getVal(); XMCerrL[i]=-ptMC.getAsymErrorLo(); XMCerrH[i]=ptMC.getAsymErrorHi(); YMC[i]=effMC.getVal(); YMCerrLo[i]=-effMC.getAsymErrorLo(); YMCerrHi[i]=effMC.getAsymErrorHi(); } grMC=new TGraphAsymmErrors(binSize,XMC,YMC,XMCerrL,XMCerrH,YMCerrLo,YMCerrHi); cout << "MC efficiency: " << endl; cout << "YMC: " << effMC.getVal()<< " +/- " << - effMC.getAsymErrorLo() << endl; cout << "YMCerrLo: " <<- effMC.getAsymErrorLo() << endl; cout << "YMCerrHi: " << effMC.getAsymErrorHi() << endl; grMC->SetLineColor(kRed); grMC->SetMarkerColor(kRed); ///**/// //* TFile *f_RD= new TFile("../efficiency-data-WptCutToHLT_eta_P.root","read"); RooDataSet *datasetRD = (RooDataSet*)f_RD->Get("WptCutToHLT/efficiency/cnt_eff"); //RooDataSet *datasetMC = (RooDataSet*)f_MC->Get("tpTree/Track_with_TightCombRelIso_to_Mu15_eta2p1_pt/fit_eff"); cout<<"ntry: "<<datasetRD->numEntries()<<endl; double XMC[binSize],XMCerrL[binSize],XMCerrH[binSize],YMC[binSize],YMCerrLo[binSize],YMCerrHi[binSize]; for(int i(0); i<datasetRD->numEntries();i++) { const RooArgSet &pointRD=*datasetRD->get(i); RooRealVar &ptRD=pointRD["probe_sc_eta"],&effRD = pointRD["efficiency"]; XMC[i]=ptRD.getVal(); XMCerrL[i]=-ptRD.getAsymErrorLo(); XMCerrH[i]=ptRD.getAsymErrorHi(); YMC[i]=effRD.getVal(); YMCerrLo[i]=-effRD.getAsymErrorLo(); YMCerrHi[i]=effRD.getAsymErrorHi(); } grRD=new TGraphAsymmErrors(binSize,XMC,YMC,XMCerrL,XMCerrH,YMCerrLo,YMCerrHi); cout << "RD efficiency: " << endl; cout << "YMC: " << effRD.getVal()<< " +/- " <<- effRD.getAsymErrorLo() << endl; cout << "YMCerrLo: " <<- effRD.getAsymErrorLo() << endl; cout << "YMCerrHi: " << effRD.getAsymErrorHi() << endl; cout << "Scale factor " << effRD.getVal()/effMC.getVal() << endl; cout<<"Lo:"<<effRD.getVal()/effMC.getVal()*sqrt(effRD.getAsymErrorLo()*effRD.getAsymErrorLo()/effRD.getVal()/effRD.getVal() + effMC.getAsymErrorLo()*effMC.getAsymErrorLo()/effMC.getVal()/effMC.getVal() ) << endl; cout<<"High:"<<effRD.getVal()/effMC.getVal()*sqrt(effRD.getAsymErrorHi()*effRD.getAsymErrorHi()/effRD.getVal()/effRD.getVal() + effMC.getAsymErrorHi()*effMC.getAsymErrorHi()/effMC.getVal()/effMC.getVal() ) << endl; grRD->SetLineColor(kBlue); grRD->SetMarkerColor(kBlue); ///***/// //myCan->SetLogx(); // grMC->Draw("AP"); grRD->Draw("AP"); grRD->SetMinimum(0.8); grRD->SetMaximum(1.04); grRD->GetXaxis()->SetNdivisions(505); grMC->Draw("psame"); //TLegend *Lgd = new TLegend(.70, .30,.80,.40); TLegend *Lgd = new TLegend(.70, .30,.80,.40); Lgd->AddEntry(grMC,"MC","lep"); Lgd->AddEntry(grRD,"RD","lep"); Lgd->SetFillColor(0); Lgd->Draw(); //grRD->Draw("AP"); //grMC->Draw("psame"); myCan->SaveAs("trig_eta_P.png"); myCan->SaveAs("trig_eta_P.eps"); }
void makeWorkspace(double mh, TH1* data, std::map<std::string, double> sparams, std::map<std::string, double> bparams, std::string cat, bool maketoy=true, bool useSignalInterpol=true) { RooMsgService::instance().setSilentMode(kTRUE); RooMsgService::instance().setGlobalKillBelow(RooFit::WARNING) ; stringstream mh_ss; mh_ss << mh; std::cout << "Creating datacard for " << mh_ss.str() << " GeV mass point, category " << cat << " ... " << std::endl; std::stringstream card_name_ss; card_name_ss << "card_"; card_name_ss << "m" << mh_ss.str() << "_"; card_name_ss << cat; std::string card_name = card_name_ss.str(); std::string workspace = card_name+"_workspace.root"; /* Dark photon mass and dimuon mass variables */ const char* massvarstr = "CMS_darkphoton_mass"; const char* scalevarstr = "CMS_darkphoton_scale"; const char* resvarstr = "CMS_darkphoton_res"; int fitbins = data->GetNbinsX(); double massLow = data->GetXaxis()->GetXmin(); double massHigh = data->GetXaxis()->GetXmax(); std::cout << "Will perform a binned fit with " << fitbins << " bins in the mass range " << massLow << " to " << massHigh << std::endl; RooRealVar rmh ("MH" , "MH" , mh); RooRealVar m2mu (massvarstr , "Dimuon mass", mh , massLow, massHigh, "GeV/c^{2}"); RooRealVar scale(scalevarstr, "Scale unc. ", 0.0 , 0.0 , 1.0 , "GeV/c^{2}"); RooRealVar res (resvarstr , "RFes. unc. ", 0.0 , 0.0 , 1.0); m2mu.setBins(data->GetNbinsX()); /* Extract shape parameters */ std::string spdf = "sig_mass_"; std::string bpdf = "bkg_mass_"; spdf += cat; bpdf += cat; RooRealVar sig_norm((spdf+"_pdf_norm").c_str(), "", sparams["yield"]); RooRealVar bkg_norm((bpdf+"_pdf_norm").c_str(), "", bparams["yield"]); std::cout << "Expected signal yield : " << sig_norm.getVal() << std::endl; std::cout << "Expected background yield : " << bkg_norm.getVal() << std::endl; sig_norm.setConstant(kTRUE); bkg_norm.setConstant(kTRUE); /* Define PDFs */ // Background int bkgorder = bparams.size() - 3; RooArgList argl; std::vector<RooRealVar*> bargs; for (std::size_t i = 1; i <= bkgorder; i++) { std::stringstream argname_ss; argname_ss << "c" << i; double argval = bparams[argname_ss.str().c_str()]; bargs.push_back(new RooRealVar(argname_ss.str().c_str(), "", argval, argval-500., argval+500.)); argl.add(*bargs.back()); } RooBernstein bkg_mass_pdf(("bkg_mass_"+cat+"_pdf" ).c_str(), "", m2mu, argl); // Signal std::stringstream meanss; std::stringstream sigmass; double aLval = 0.0; double aRval = 0.0; double nLval = 0.0; double nRval = 0.0; if (!useSignalInterpol) { meanss << "@0 - " << sparams["m0"] << " + " << "@0*@1"; sigmass << sparams["si"] << " * " << "(1+@0)"; aLval = sparams["aL"]; aRval = sparams["aR"]; nLval = sparams["nL"]; nRval = sparams["nR"]; } else { meanss << "35 + 0.99785*(@0-35)" << " + " << "@0*@1"; sigmass << "(0.3762 + 0.012223*(@0-35))" << " * " << "(1+@1)"; aLval = 1.26833918722; aRval = 1.2945031338; nLval = 2.76027985241; nRval = 9.59850913168; } RooFormulaVar fmean ((spdf+"_fmean" ).c_str(), "", meanss .str().c_str(), RooArgList(rmh, scale)); RooFormulaVar fsigma((spdf+"_fsigma").c_str(), "", sigmass.str().c_str(), RooArgList(rmh, res )); RooRealVar raL ((spdf+"_aL" ).c_str(), "", aLval); RooRealVar rnL ((spdf+"_nL" ).c_str(), "", nLval); RooRealVar raR ((spdf+"_aR" ).c_str(), "", aRval); RooRealVar rnR ((spdf+"_nR" ).c_str(), "", nRval); RooDoubleCB sig_mass_pdf(("sig_mass_"+cat+"_pdf" ).c_str(), "", m2mu, fmean, fsigma, raL, rnL, raR, rnR); /* RooDataSet of the observed data */ std::cout << "Generating toy data with " << int(bparams["yield"]) << " events\n"; RooDataSet* dset = bkg_mass_pdf.generate(m2mu, int(bparams["yield"])); TH1F dhist("dhist", "", fitbins, massLow, massHigh); for (int i = 0; i < dset->numEntries(); i++) { const RooArgSet* aset = dset->get(i); double mass = aset->getRealValue(massvarstr); dhist.Fill(mass); } RooDataHist data_obs("data_obs", "", RooArgList(m2mu), (maketoy ? &dhist : data)); RooWorkspace w("w", ""); w.import(data_obs); w.import(sig_norm); w.import(bkg_norm); w.import(sig_mass_pdf); w.import(bkg_mass_pdf); w.writeToFile(workspace.c_str()); /* Create the data card text file */ std::string card = createCardTemplate(mh, cat, workspace); std::ofstream ofile; ofile.open ((card_name +".txt").c_str()); ofile << card; ofile.close(); for (std::size_t i = 0; i < bargs.size(); i++) { if (bargs[i]) delete bargs[i]; } }
void OneSidedFrequentistUpperLimitWithBands_intermediate(const char* infile = "", const char* workspaceName = "combined", const char* modelConfigName = "ModelConfig", const char* dataName = "obsData"){ double confidenceLevel=0.95; // degrade/improve number of pseudo-experiments used to define the confidence belt. // value of 1 corresponds to default number of toys in the tail, which is 50/(1-confidenceLevel) double additionalToysFac = 1.; int nPointsToScan = 30; // number of steps in the parameter of interest int nToyMC = 100; // number of toys used to define the expected limit and band TStopwatch t; t.Start(); ///////////////////////////////////////////////////////////// // First part is just to access a user-defined file // or create the standard example file if it doesn't exist //////////////////////////////////////////////////////////// const char* filename = ""; if (!strcmp(infile,"")) filename = "results/example_combined_GaussExample_model.root"; else filename = infile; // Check if example input file exists TFile *file = TFile::Open(filename); // if input file was specified byt not found, quit if(!file && strcmp(infile,"")){ cout <<"file not found" << endl; return; } // if default file not found, try to create it if(!file ){ // Normally this would be run on the command line cout <<"will run standard hist2workspace example"<<endl; gROOT->ProcessLine(".! prepareHistFactory ."); gROOT->ProcessLine(".! hist2workspace config/example.xml"); cout <<"\n\n---------------------"<<endl; cout <<"Done creating example input"<<endl; cout <<"---------------------\n\n"<<endl; } // now try to access the file again file = TFile::Open(filename); if(!file){ // if it is still not there, then we can't continue cout << "Not able to run hist2workspace to create example input" <<endl; return; } ///////////////////////////////////////////////////////////// // Now get the data and workspace //////////////////////////////////////////////////////////// // get the workspace out of the file RooWorkspace* w = (RooWorkspace*) file->Get(workspaceName); if(!w){ cout <<"workspace not found" << endl; return; } // get the modelConfig out of the file ModelConfig* mc = (ModelConfig*) w->obj(modelConfigName); // get the modelConfig out of the file RooAbsData* data = w->data(dataName); // make sure ingredients are found if(!data || !mc){ w->Print(); cout << "data or ModelConfig was not found" <<endl; return; } cout << "Found data and ModelConfig:" <<endl; mc->Print(); ///////////////////////////////////////////////////////////// // Now get the POI for convenience // you may want to adjust the range of your POI //////////////////////////////////////////////////////////// RooRealVar* firstPOI = (RooRealVar*) mc->GetParametersOfInterest()->first(); // firstPOI->setMin(0); // firstPOI->setMax(10); ///////////////////////////////////////////// // create and use the FeldmanCousins tool // to find and plot the 95% confidence interval // on the parameter of interest as specified // in the model config // REMEMBER, we will change the test statistic // so this is NOT a Feldman-Cousins interval FeldmanCousins fc(*data,*mc); fc.SetConfidenceLevel(confidenceLevel); fc.AdditionalNToysFactor(additionalToysFac); // improve sampling that defines confidence belt // fc.UseAdaptiveSampling(true); // speed it up a bit, but don't use for expectd limits fc.SetNBins(nPointsToScan); // set how many points per parameter of interest to scan fc.CreateConfBelt(true); // save the information in the belt for plotting ///////////////////////////////////////////// // Feldman-Cousins is a unified limit by definition // but the tool takes care of a few things for us like which values // of the nuisance parameters should be used to generate toys. // so let's just change the test statistic and realize this is // no longer "Feldman-Cousins" but is a fully frequentist Neyman-Construction. // ProfileLikelihoodTestStatModified onesided(*mc->GetPdf()); // fc.GetTestStatSampler()->SetTestStatistic(&onesided); // ((ToyMCSampler*) fc.GetTestStatSampler())->SetGenerateBinned(true); ToyMCSampler* toymcsampler = (ToyMCSampler*) fc.GetTestStatSampler(); ProfileLikelihoodTestStat* testStat = dynamic_cast<ProfileLikelihoodTestStat*>(toymcsampler->GetTestStatistic()); testStat->SetOneSided(true); // test speedups: testStat->SetReuseNLL(true); // toymcsampler->setUseMultiGen(true); // not fully validated // Since this tool needs to throw toy MC the PDF needs to be // extended or the tool needs to know how many entries in a dataset // per pseudo experiment. // In the 'number counting form' where the entries in the dataset // are counts, and not values of discriminating variables, the // datasets typically only have one entry and the PDF is not // extended. if(!mc->GetPdf()->canBeExtended()){ if(data->numEntries()==1) fc.FluctuateNumDataEntries(false); else cout <<"Not sure what to do about this model" <<endl; } // We can use PROOF to speed things along in parallel ProofConfig pc(*w, 4, "",false); if(mc->GetGlobalObservables()){ cout << "will use global observables for unconditional ensemble"<<endl; mc->GetGlobalObservables()->Print(); toymcsampler->SetGlobalObservables(*mc->GetGlobalObservables()); } toymcsampler->SetProofConfig(&pc); // enable proof // Now get the interval PointSetInterval* interval = fc.GetInterval(); ConfidenceBelt* belt = fc.GetConfidenceBelt(); // print out the iterval on the first Parameter of Interest cout << "\n95% interval on " <<firstPOI->GetName()<<" is : ["<< interval->LowerLimit(*firstPOI) << ", "<< interval->UpperLimit(*firstPOI) <<"] "<<endl; // get observed UL and value of test statistic evaluated there RooArgSet tmpPOI(*firstPOI); double observedUL = interval->UpperLimit(*firstPOI); firstPOI->setVal(observedUL); double obsTSatObsUL = fc.GetTestStatSampler()->EvaluateTestStatistic(*data,tmpPOI); // Ask the calculator which points were scanned RooDataSet* parameterScan = (RooDataSet*) fc.GetPointsToScan(); RooArgSet* tmpPoint; // make a histogram of parameter vs. threshold TH1F* histOfThresholds = new TH1F("histOfThresholds","", parameterScan->numEntries(), firstPOI->getMin(), firstPOI->getMax()); histOfThresholds->GetXaxis()->SetTitle(firstPOI->GetName()); histOfThresholds->GetYaxis()->SetTitle("Threshold"); // loop through the points that were tested and ask confidence belt // what the upper/lower thresholds were. // For FeldmanCousins, the lower cut off is always 0 for(Int_t i=0; i<parameterScan->numEntries(); ++i){ tmpPoint = (RooArgSet*) parameterScan->get(i)->clone("temp"); double arMax = belt->GetAcceptanceRegionMax(*tmpPoint); double poiVal = tmpPoint->getRealValue(firstPOI->GetName()) ; histOfThresholds->Fill(poiVal,arMax); } TCanvas* c1 = new TCanvas(); c1->Divide(2); c1->cd(1); histOfThresholds->SetMinimum(0); histOfThresholds->Draw(); c1->cd(2); ///////////////////////////////////////////////////////////// // Now we generate the expected bands and power-constriant //////////////////////////////////////////////////////////// // First: find parameter point for mu=0, with conditional MLEs for nuisance parameters RooAbsReal* nll = mc->GetPdf()->createNLL(*data); RooAbsReal* profile = nll->createProfile(*mc->GetParametersOfInterest()); firstPOI->setVal(0.); profile->getVal(); // this will do fit and set nuisance parameters to profiled values RooArgSet* poiAndNuisance = new RooArgSet(); if(mc->GetNuisanceParameters()) poiAndNuisance->add(*mc->GetNuisanceParameters()); poiAndNuisance->add(*mc->GetParametersOfInterest()); w->saveSnapshot("paramsToGenerateData",*poiAndNuisance); RooArgSet* paramsToGenerateData = (RooArgSet*) poiAndNuisance->snapshot(); cout << "\nWill use these parameter points to generate pseudo data for bkg only" << endl; paramsToGenerateData->Print("v"); double CLb=0; double CLbinclusive=0; // Now we generate background only and find distribution of upper limits TH1F* histOfUL = new TH1F("histOfUL","",100,0,firstPOI->getMax()); histOfUL->GetXaxis()->SetTitle("Upper Limit (background only)"); histOfUL->GetYaxis()->SetTitle("Entries"); for(int imc=0; imc<nToyMC; ++imc){ // set parameters back to values for generating pseudo data w->loadSnapshot("paramsToGenerateData"); // in 5.30 there is a nicer way to generate toy data & randomize global obs RooAbsData* toyData = toymcsampler->GenerateToyData(*paramsToGenerateData); // get test stat at observed UL in observed data firstPOI->setVal(observedUL); double toyTSatObsUL = fc.GetTestStatSampler()->EvaluateTestStatistic(*toyData,tmpPOI); // toyData->get()->Print("v"); // cout <<"obsTSatObsUL " <<obsTSatObsUL << "toyTS " << toyTSatObsUL << endl; if(obsTSatObsUL < toyTSatObsUL) // (should be checked) CLb+= (1.)/nToyMC; if(obsTSatObsUL <= toyTSatObsUL) // (should be checked) CLbinclusive+= (1.)/nToyMC; // loop over points in belt to find upper limit for this toy data double thisUL = 0; for(Int_t i=0; i<parameterScan->numEntries(); ++i){ tmpPoint = (RooArgSet*) parameterScan->get(i)->clone("temp"); double arMax = belt->GetAcceptanceRegionMax(*tmpPoint); firstPOI->setVal( tmpPoint->getRealValue(firstPOI->GetName()) ); double thisTS = fc.GetTestStatSampler()->EvaluateTestStatistic(*toyData,tmpPOI); if(thisTS<=arMax){ thisUL = firstPOI->getVal(); } else{ break; } } histOfUL->Fill(thisUL); delete toyData; } histOfUL->Draw(); c1->SaveAs("one-sided_upper_limit_output.pdf"); // if you want to see a plot of the sampling distribution for a particular scan point: // Now find bands and power constraint Double_t* bins = histOfUL->GetIntegral(); TH1F* cumulative = (TH1F*) histOfUL->Clone("cumulative"); cumulative->SetContent(bins); double band2sigDown=0, band1sigDown=0, bandMedian=0, band1sigUp=0,band2sigUp=0; for(int i=1; i<=cumulative->GetNbinsX(); ++i){ if(bins[i]<RooStats::SignificanceToPValue(2)) band2sigDown=cumulative->GetBinCenter(i); if(bins[i]<RooStats::SignificanceToPValue(1)) band1sigDown=cumulative->GetBinCenter(i); if(bins[i]<0.5) bandMedian=cumulative->GetBinCenter(i); if(bins[i]<RooStats::SignificanceToPValue(-1)) band1sigUp=cumulative->GetBinCenter(i); if(bins[i]<RooStats::SignificanceToPValue(-2)) band2sigUp=cumulative->GetBinCenter(i); } t.Stop(); t.Print(); cout << "-2 sigma band " << band2sigDown << endl; cout << "-1 sigma band " << band1sigDown << endl; cout << "median of band " << bandMedian << " [Power Constriant)]" << endl; cout << "+1 sigma band " << band1sigUp << endl; cout << "+2 sigma band " << band2sigUp << endl; // print out the iterval on the first Parameter of Interest cout << "\nobserved 95% upper-limit "<< interval->UpperLimit(*firstPOI) <<endl; cout << "CLb strict [P(toy>obs|0)] for observed 95% upper-limit "<< CLb <<endl; cout << "CLb inclusive [P(toy>=obs|0)] for observed 95% upper-limit "<< CLbinclusive <<endl; delete profile; delete nll; }
//____________________________________ void AddModel(RooWorkspace* ws){ // Variables RooRealVar* run = new RooRealVar("run","run number",100000,300000); RooRealVar* event = new RooRealVar("event","event number",0.,1e10); // RooRealVar* FourMu_Mass = new RooRealVar("FourMu_Mass","FourMu_Mass",6.,100.); RooRealVar* FourMu_Mass = new RooRealVar("FourMu_Mass","FourMu_Mass",0.,999.); // RooRealVar* FourMu_Mass = new RooRealVar("FourMu_Mass","FourMu_Mass",6.,20.); RooRealVar* Psi1_Mass = new RooRealVar("Psi1_Mass","Psi1_Mass",2.85,3.35); RooRealVar* Psi2_Mass = new RooRealVar("Psi2_Mass","Psi2_Mass",2.85,3.35); RooRealVar* Psi1_CTxy = new RooRealVar("Psi1_CTxy","Psi1_CTxy",-0.05,0.1); RooRealVar* Psi2_CTxy = new RooRealVar("Psi2_CTxy","Psi2_CTxy",-0.05,0.1); RooRealVar* Psi1To2_dY = new RooRealVar("Psi1To2_dY","Psi1To2_dY",0.,4.8); RooRealVar* Psi1To2Significance = new RooRealVar("Psi1To2Significance","Psi1To2Significance",0.,8); RooArgSet dataVars; dataVars.add(RooArgSet(*run,*event,*FourMu_Mass,*Psi1_Mass,*Psi2_Mass,*Psi1_CTxy,*Psi2_CTxy,*Psi1To2_dY,*Psi1To2Significance)); RooDataSet *data; //TFile* f= (TFile*)gROOT->FindObject("./data.root"); if (f) f->Close(); //f = new TFile ("./data.root","UPDATE"); //TFile* f= (TFile*)gROOT->FindObject("./Input_To_Fit_pT_Sort.root"); if (f) f->Close(); //TFile* f = new TFile ("./Input_To_Fit_pT_Sort_iter_7_Data_Good_Eff.root","READ"); TFile* f = new TFile ("./Input_To_Fit_pT_Sort_2012_Data_04_tight_mass.root","READ"); //TFile* f = new TFile ("./Input_To_Fit_pT_Sort_iter_7_Data.root","READ"); TTree *myTree = (TTree*)f->Get("PATEventTree"); data = new RooDataSet("data","data",myTree,dataVars); ///////////////////////// // Signal PDFs parameters ///////////////////////// RooRealVar* jpsi1_mass_1 = new RooRealVar("jpsi1_mass_1","",3.08988e+00); RooRealVar* jpsi1_mass_2 = new RooRealVar("jpsi1_mass_2","",3.09553e+00); RooRealVar* jpsi1_width_1 = new RooRealVar("jpsi1_width_1","",7.00000e-02); RooRealVar* jpsi1_width_2 = new RooRealVar("jpsi1_width_2","",4.30143e-01); RooFormulaVar* jpsi1_width_a = new RooFormulaVar("jpsi1_width_a","","@0*@1",RooArgList(*jpsi1_width_1,*jpsi1_width_2)); RooRealVar* frac_1 = new RooRealVar("frac_1","",3.76426e-01); RooRealVar* jpsi2_mass_1 = new RooRealVar("jpsi2_mass_1","",3.08680e+00); RooRealVar* jpsi2_mass_2 = new RooRealVar("jpsi2_mass_2","",3.09285e+00); RooRealVar* jpsi2_width_1 = new RooRealVar("jpsi2_width_1","",7.00000e-02); RooRealVar* jpsi2_width_2 = new RooRealVar("jpsi2_width_2","",4.79895e-01); RooFormulaVar* jpsi2_width_a = new RooFormulaVar("jpsi2_width_a","","@0*@1",RooArgList(*jpsi2_width_1,*jpsi2_width_2)); RooRealVar* frac_2 = new RooRealVar("frac_2","",5.00000e-01); RooRealVar* R_mean_coreCT1 = new RooRealVar("R_mean_coreCT1","",2.63860e-05); RooRealVar* R_mean_tailCT1 = new RooRealVar("R_mean_tailCT1","",1.19874e-03); RooRealVar* R_sigma_coreCT1 = new RooRealVar("R_sigma_coreCT1","",2.72201e-03); RooRealVar* R_sigma_tailCT1 = new RooRealVar("R_sigma_tailCT1","",2.72258e+00); RooFormulaVar* R_sigma_totCT1 = new RooFormulaVar("R_sigma_totCT1","","@0*@1",RooArgList(*R_sigma_coreCT1,*R_sigma_tailCT1)); RooRealVar* R_fracCT1 = new RooRealVar("R_fracCT1","",8.47797e-01); RooRealVar* R_mean_core = new RooRealVar("R_mean_core","",4.08278e-01); RooRealVar* R_sigma_core = new RooRealVar("R_sigma_core","",2.17748e-01); RooRealVar* etab_lambda = new RooRealVar("etab_lambda","",6.76288e-01); RooGaussian jpsi1mass_1("jpsi1mass_1","jpsi mass distribution",*Psi1_Mass,*jpsi1_mass_1,*jpsi1_width_1); RooGaussian jpsi1mass_2("jpsi1mass_2","jpsi mass distribution",*Psi1_Mass,*jpsi1_mass_1,*jpsi1_width_a); RooAddPdf jpsi1mass("jpsi1mass","jpsi1 mass distribution",RooArgList(jpsi1mass_1,jpsi1mass_2),RooArgList(*frac_1)); RooGaussian jpsi2mass_1("jpsi2mass_1","jpsi mass distribution",*Psi2_Mass,*jpsi2_mass_1,*jpsi2_width_1); RooGaussian jpsi2mass_2("jpsi2mass_2","jpsi mass distribution",*Psi2_Mass,*jpsi2_mass_1,*jpsi2_width_a); RooAddPdf jpsi2mass("jpsi2mass","jpsi2 mass distribution",RooArgList(jpsi2mass_1,jpsi2mass_2),RooArgList(*frac_2)); RooGaussian ct_1a("ct_1a","ct distribution",*Psi1_CTxy,*R_mean_coreCT1,*R_sigma_coreCT1); RooGaussian ct_1b("ct_1b","ct distribution",*Psi1_CTxy,*R_mean_tailCT1,*R_sigma_totCT1); RooAddPdf ct_1("ct_1","ct distribution",RooArgList(ct_1a,ct_1b),RooArgList(*R_fracCT1)); RooGaussModel resolution_core("resolution_core","",*Psi1To2Significance,*R_mean_core,*R_sigma_core); RooDecay sig_distT("sig_distT","",*Psi1To2Significance,*etab_lambda,resolution_core,RooDecay::SingleSided); RooProdPdf sig_model("sig_model","",RooArgList(jpsi1mass,jpsi2mass,ct_1,sig_distT)); ///////////////////////// // B bkg PDF ///////////////////////// RooRealVar* Bbkg_jpsi1_mass_1 = new RooRealVar("Bbkg_jpsi1_mass_1","",3.08988e+00); RooRealVar* Bbkg_jpsi1_mass_2 = new RooRealVar("Bbkg_jpsi1_mass_2","",3.09553e+00); RooRealVar* Bbkg_jpsi1_width_1 = new RooRealVar("Bbkg_jpsi1_width_1","",7.00000e-02); RooRealVar* Bbkg_jpsi1_width_2 = new RooRealVar("Bbkg_jpsi1_width_2","",4.30143e-01); RooFormulaVar* Bbkg_jpsi1_width_a = new RooFormulaVar("Bbkg_jpsi1_width_a","","@0*@1",RooArgList(*Bbkg_jpsi1_width_1,*Bbkg_jpsi1_width_2)); RooRealVar* Bbkg_frac_1 = new RooRealVar("Bbkg_frac_1","",3.76426e-01); RooRealVar* Bbkg_jpsi2_mass_1 = new RooRealVar("Bbkg_jpsi2_mass_1","",3.08680e+00); RooRealVar* Bbkg_jpsi2_mass_2 = new RooRealVar("Bbkg_jpsi2_mass_2","",3.09285e+00); RooRealVar* Bbkg_jpsi2_width_1 = new RooRealVar("Bbkg_jpsi2_width_1","",7.00000e-02); RooRealVar* Bbkg_jpsi2_width_2 = new RooRealVar("Bbkg_jpsi2_width_2","",4.79895e-01); RooFormulaVar* Bbkg_jpsi2_width_a = new RooFormulaVar("Bbkg_jpsi2_width_a","","@0*@1",RooArgList(*Bbkg_jpsi2_width_1,*Bbkg_jpsi2_width_2)); RooRealVar* Bbkg_frac_2 = new RooRealVar("Bbkg_frac_2","",5.00000e-01); RooRealVar* Bbkg_mean_CT1 = new RooRealVar("Bbkg_mean_CT1","",6.51060e-04); RooRealVar* Bbkg_width_CT1 = new RooRealVar("Bbkg_width_CT1","",3.77146e-03); //RooRealVar* Bbkg_lambda_CT1 = new RooRealVar("Bbkg_lambda_CT1","Bbkg_lambda_CT1",1.59424e-02); // for eff_cut dataset //RooRealVar* Bbkg_lambda_CT1 = new RooRealVar("Bbkg_lambda_CT1","Bbkg_lambda_CT1",1.60933e-02); // for eff_cut dataset RooRealVar* Bbkg_lambda_CT1 = new RooRealVar("Bbkg_lambda_CT1","Bbkg_lambda_CT1",1.86124e-02); // for all dataset RooRealVar* Bbkg_p3_distT = new RooRealVar("Bbkg_p3_distT","",1.18073e+00); RooRealVar* Bbkg_p4_distT = new RooRealVar("Bbkg_p4_distT","",5.15922e-01); RooRealVar* Bbkg_lambda1 = new RooRealVar("Bbkg_lambda1","",9.99999e+01); RooGaussian Bbkg_jpsi1mass_1("Bbkg_jpsi1mass_1","jpsi mass distribution",*Psi1_Mass,*Bbkg_jpsi1_mass_1,*Bbkg_jpsi1_width_1); RooGaussian Bbkg_jpsi1mass_2("Bbkg_jpsi1mass_2","jpsi mass distribution",*Psi1_Mass,*Bbkg_jpsi1_mass_1,*Bbkg_jpsi1_width_a); RooAddPdf Bbkg_jpsi1mass("Bbkg_jpsi1mass","jpsi1 mass distribution",RooArgList(Bbkg_jpsi1mass_1,Bbkg_jpsi1mass_2),RooArgList(*Bbkg_frac_1)); RooGaussian Bbkg_jpsi2mass_1("Bbkg_jpsi2mass_1","jpsi mass distribution",*Psi2_Mass,*Bbkg_jpsi2_mass_1,*Bbkg_jpsi2_width_1); RooGaussian Bbkg_jpsi2mass_2("Bbkg_jpsi2mass_2","jpsi mass distribution",*Psi2_Mass,*Bbkg_jpsi2_mass_1,*Bbkg_jpsi2_width_a); RooAddPdf Bbkg_jpsi2mass("Bbkg_jpsi2mass","jpsi1 mass distribution",RooArgList(Bbkg_jpsi2mass_1,Bbkg_jpsi2mass_2),RooArgList(*Bbkg_frac_2)); RooGaussModel resolution_R1("resolution_R1","",*Psi1_CTxy,*Bbkg_mean_CT1,*Bbkg_width_CT1); RooDecay Bbkg_CT1("Bbkg_CT1","",*Psi1_CTxy,*Bbkg_lambda_CT1,resolution_R1,RooDecay::SingleSided); RooGaussModel resolution_core2("resolution_core2","",*Psi1To2Significance,*Bbkg_p3_distT,*Bbkg_p4_distT); RooDecay Bbkg_distT("Bbkg_distT","",*Psi1To2Significance,*Bbkg_lambda1,resolution_core2,RooDecay::SingleSided); RooProdPdf Bbkg_model("Bbkg_model","",RooArgList(Bbkg_jpsi1mass,Bbkg_jpsi2mass,Bbkg_CT1,Bbkg_distT)); ///////////////////////// // bkg PDF ///////////////////////// // jpsi-sideband case RooRealVar* bkg_jpsi1_mass_1 = new RooRealVar("bkg_jpsi1_mass_1","",3.08988e+00); //RooRealVar* bkg_jpsi1_mass_2 = new RooRealVar("bkg_jpsi1_mass_2","",3.08988e+00); RooRealVar* bkg_jpsi1_width_1 = new RooRealVar("bkg_jpsi1_width_1","",7.00000e-02); RooRealVar* bkg_jpsi1_width_2 = new RooRealVar("bkg_jpsi1_width_2","",4.30143e-01); RooFormulaVar* bkg_jpsi1_width_a = new RooFormulaVar("bkg_jpsi1_width_a","","@0*@1",RooArgList(*bkg_jpsi1_width_1,*bkg_jpsi1_width_2)); RooRealVar* bkg_frac_6 = new RooRealVar("bkg_frac_6","",3.76426e-01); RooRealVar* bkg_p3 = new RooRealVar("bkg_p3","",-2.10268e-01); RooRealVar* bkg_p4 = new RooRealVar("bkg_p4","",-1.95504e-01); RooRealVar* bkg_p5 = new RooRealVar("bkg_p5","",5.00755e-02); RooRealVar* bkg1_R_mean_core = new RooRealVar("bkg1_R_mean_core","",1.04093e-02); RooRealVar* bkg1_R_mean_tail = new RooRealVar("bkg1_R_mean_tail","",-2.51869e-04); RooRealVar* bkg1_R_sigma_core = new RooRealVar("bkg1_R_sigma_core","",1.24609e-02); RooRealVar* bkg1_R_sigma_tail = new RooRealVar("bkg1_R_sigma_tail","",2.63519e-01); RooRealVar* bkg_frac_1 = new RooRealVar("bkg_frac_1","",7.07283e-01); //RooRealVar* bkg1_R_mean_core = new RooRealVar("bkg1_R_mean_core","",2.63860e-05); //RooRealVar* bkg1_R_mean_tail = new RooRealVar("bkg1_R_mean_tail","",1.19874e-03); //RooRealVar* bkg1_R_sigma_core = new RooRealVar("bkg1_R_sigma_core","",2.72201e-03); //RooRealVar* bkg1_R_sigma_tail = new RooRealVar("bkg1_R_sigma_tail","",2.72258e+00); //RooRealVar* bkg_frac_1 = new RooRealVar("bkg_frac_1","",8.47797e-01); RooFormulaVar* bkg1_R_sigma_tot = new RooFormulaVar("bkg1_R_sigma_tot","","@0*@1",RooArgList(*bkg1_R_sigma_tail,*bkg1_R_sigma_core)); //RooGaussian bkg_jpsi1mass("bkg_jpsi1mass","jpsi mass distribution",*Psi1_Mass,*bkg_jpsi1_mass_1,*bkg_jpsi1_width_1); RooGaussian bkg_jpsi1mass_1("bkg_jpsi1mass_1","jpsi mass distribution",*Psi1_Mass,*bkg_jpsi1_mass_1,*bkg_jpsi1_width_1); RooGaussian bkg_jpsi1mass_2("bkg_jpsi1mass_2","jpsi mass distribution",*Psi1_Mass,*bkg_jpsi1_mass_1,*bkg_jpsi1_width_a); RooAddPdf bkg_jpsi1mass("bkg_jpsi1mass","jpsi1 mass distribution",RooArgList(bkg_jpsi1mass_1,bkg_jpsi1mass_2),RooArgList(*bkg_frac_6)); RooChebychev bkg_jpsi1mass_Pol("bkg_jpsi1mass_Pol","",*Psi2_Mass,RooArgList(*bkg_p3,*bkg_p4,*bkg_p5)); RooGaussian bkg_ctSB1_1a("bkg_ctSB1_1a","ct distribution",*Psi1_CTxy,*bkg1_R_mean_core,*bkg1_R_sigma_core); RooGaussian bkg_ctSB1_1b("bkg_ctSB1_1b","ct distribution",*Psi1_CTxy,*bkg1_R_mean_tail,*bkg1_R_sigma_tot); RooAddPdf bkg_CT1_SB1("bkg_CT1_SB1","ct distribution",RooArgList(bkg_ctSB1_1a,bkg_ctSB1_1b),RooArgList(*bkg_frac_1)); //RooRealVar* bkg_p3_distT = new RooRealVar("bkg_p3_distT","",2.87578e-01); //RooRealVar* bkg_p4_distT = new RooRealVar("bkg_p4_distT","",1.26380e-01); //RooRealVar* bkg_lambda1 = new RooRealVar("bkg_lambda1","",3.65276e+00); //RooGaussModel resolution_core3("resolution_core3","",*Psi1To2Significance,*bkg_p3_distT,*bkg_p4_distT); //RooDecay bkg_distT("bkg_distT","",*Psi1To2Significance,*bkg_lambda1,resolution_core3,RooDecay::SingleSided); RooRealVar* bkg_co0 = new RooRealVar("bkg_co0","",9.99840e-01); RooRealVar* bkg_co1 = new RooRealVar("bkg_co1","",2.00471e-06); RooRealVar* bkg_flau = new RooRealVar("bkg_flau","",6.48517e-01); RooRealVar* bkg_meanlandau = new RooRealVar("bkg_meanlandau","",1.00181e+00); RooRealVar* bkg_sigmalandau = new RooRealVar("bkg_sigmalandau","",4.35740e-01); RooLandau bkg_landau("bkg_landau", "bkg_landau", *Psi1To2Significance, *bkg_meanlandau, *bkg_sigmalandau); RooChebychev bkg_polyshape("bkg_polyshape","",*Psi1To2Significance,RooArgList(*bkg_co0,*bkg_co1)); RooAddPdf bkg_distT("bkg_distT","", RooArgList(bkg_landau,bkg_polyshape),*bkg_flau); RooProdPdf bkg_mass1("bkg_mass1","",RooArgList(bkg_jpsi1mass,bkg_jpsi1mass_Pol,bkg_CT1_SB1,bkg_distT)); // sideband-jpsi case RooRealVar* bkg_jpsi2_mass_1 = new RooRealVar("bkg_jpsi2_mass_1","",3.08680e+00); //RooRealVar* bkg_jpsi2_mass_2 = new RooRealVar("bkg_jpsi2_mass_2","",3.08680e+00); RooRealVar* bkg_jpsi2_width_1 = new RooRealVar("bkg_jpsi2_width_1","",7.00000e-02); RooRealVar* bkg_jpsi2_width_2 = new RooRealVar("bkg_jpsi2_width_2","",4.79895e-01); RooFormulaVar* bkg_jpsi2_width_a = new RooFormulaVar("bkg_jpsi1_width_a","","@0*@1",RooArgList(*bkg_jpsi2_width_1,*bkg_jpsi2_width_2)); RooRealVar* bkg_frac_7 = new RooRealVar("bkg_frac_7","",5.00000e-01); RooRealVar* bkg_p0 = new RooRealVar("bkg_p0","",-2.93132e-01); RooRealVar* bkg_p1 = new RooRealVar("bkg_p1","",-3.89092e-01); RooRealVar* bkg_p2 = new RooRealVar("bkg_p2","",1.94808e-01); RooRealVar* bkg3_R_mean_core = new RooRealVar("bkg3_R_mean_core","",3.60489e-02); RooRealVar* bkg3_R_mean_tail = new RooRealVar("bkg3_R_mean_tail","",4.32342e-03); RooRealVar* bkg3_R_sigma_core = new RooRealVar("bkg3_R_sigma_core","",2.89854e-02); RooRealVar* bkg3_R_sigma_tail = new RooRealVar("bkg3_R_sigma_tail","",3.60637e-01); RooRealVar* bkg_frac_3 = new RooRealVar("bkg_frac_3","",6.27677e-02); RooFormulaVar* bkg3_R_sigma_tot = new RooFormulaVar("bkg3_R_sigma_tot","","@0*@1",RooArgList(*bkg3_R_sigma_tail,*bkg3_R_sigma_core)); //RooGaussian bkg_jpsi2mass("bkg_jpsi2mass","jpsi mass distribution",*Psi2_Mass,*bkg_jpsi2_mass_1,*bkg_jpsi2_width_1); RooGaussian bkg_jpsi2mass_1("bkg_jpsi2mass_1","jpsi mass distribution",*Psi2_Mass,*bkg_jpsi2_mass_1,*bkg_jpsi2_width_1); RooGaussian bkg_jpsi2mass_2("bkg_jpsi2mass_2","jpsi mass distribution",*Psi2_Mass,*bkg_jpsi2_mass_1,*bkg_jpsi2_width_a); RooAddPdf bkg_jpsi2mass("bkg_jpsi2mass","jpsi2 mass distribution",RooArgList(bkg_jpsi2mass_1,bkg_jpsi2mass_2),RooArgList(*bkg_frac_7)); RooChebychev bkg_jpsi2mass_Pol("bkg_jpsi2mass_Pol","",*Psi1_Mass,RooArgList(*bkg_p0,*bkg_p1,*bkg_p2)); RooGaussian bkg_ctSB2_1a("bkg_ctSB2_1a","ct distribution",*Psi1_CTxy,*bkg3_R_mean_core,*bkg3_R_sigma_core); RooGaussian bkg_ctSB2_1b("bkg_ctSB2_1b","ct distribution",*Psi1_CTxy,*bkg3_R_mean_tail,*bkg3_R_sigma_tot); RooAddPdf bkg_CT1_SB2("bkg_CT1_SB2","ct distribution",RooArgList(bkg_ctSB2_1a,bkg_ctSB2_1b),RooArgList(*bkg_frac_3)); //RooRealVar* bkg_p5_distT = new RooRealVar("bkg_p5_distT","",2.41297e-01); //RooRealVar* bkg_p6_distT = new RooRealVar("bkg_p6_distT","",7.29316e-02); //RooRealVar* bkg_lambda2 = new RooRealVar("bkg_lambda2","",4.66802e+00); //RooGaussModel resolution_core4("resolution_core4","",*Psi1To2Significance,*bkg_p5_distT,*bkg_p6_distT); //RooDecay bkg_distT2("bkg_distT2","",*Psi1To2Significance,*bkg_lambda2,resolution_core4,RooDecay::SingleSided); RooRealVar* bkg_co02 = new RooRealVar("bkg_co02","", 6.58858e-01); RooRealVar* bkg_co12 = new RooRealVar("bkg_co12","", 2.48596e-05); RooRealVar* bkg_flau2 = new RooRealVar("bkg_flau2","",5.33780e-01); RooRealVar* bkg_meanlandau2 = new RooRealVar("bkg_meanlandau2","",1.09999e+00); RooRealVar* bkg_sigmalandau2 = new RooRealVar("bkg_sigmalandau2","",4.64046e-01); RooChebychev bkg_polyshape2("bkg_polyshape2","",*Psi1To2Significance,RooArgList(*bkg_co02,*bkg_co12)); RooLandau bkg_landau2("bkg_landau2", "bkg_landau2", *Psi1To2Significance, *bkg_meanlandau2, *bkg_sigmalandau2); RooAddPdf bkg_distT2("bkg_distT2","", RooArgList(bkg_landau2,bkg_polyshape2),*bkg_flau2); RooProdPdf bkg_mass2("bkg_mass2","",RooArgList(bkg_jpsi2mass,bkg_jpsi2mass_Pol,bkg_CT1_SB2,bkg_distT2)); // fraction for the J/psi-flat flat-J/psi ratio (Andrew: I think this is defined as (# J/psi-flat)/(# J/psi-flat + # flat-J/psi)) //RooRealVar* bkg_frac_5 = new RooRealVar("bkg_frac_5","",); //RooRealVar* bkg_frac_5 = new RooRealVar("bkg_frac_5","",5.95167e-01); // for eff_cut dataset RooRealVar* bkg_frac_5 = new RooRealVar("bkg_frac_5","",8.92796e-01); // for all dataset RooAddPdf bkg_model("bkg_model","",RooArgList(bkg_mass1,bkg_mass2),RooArgList(*bkg_frac_5)); ///////////////////////// // bkg flat flat ///////////////////////// RooRealVar* bkg7_R_mean_core = new RooRealVar("bkg7_R_mean_core","",3.45913e-03); RooRealVar* bkg7_R_sigma_core = new RooRealVar("bkg7_R_sigma_core","",1.10565e-02); RooGaussian bkg2_CT1("bkg2_CT1","ct distribution",*Psi1_CTxy,*bkg7_R_mean_core,*bkg7_R_sigma_core); //RooRealVar* bkg_p7_distT = new RooRealVar("bkg_p7_distT","",5.13453e-01); //RooRealVar* bkg_p8_distT = new RooRealVar("bkg_p8_distT","",2.85147e-01); //RooRealVar* bkg_lambda3 = new RooRealVar("bkg_lambda3","",3.54163e+00); //RooGaussModel resolution_core5("resolution_core5","",*Psi1To2Significance,*bkg_p7_distT,*bkg_p8_distT); //RooDecay bkg2_distT("bkg2_distT","",*Psi1To2Significance,*bkg_lambda3,resolution_core5,RooDecay::SingleSided); RooRealVar* bkg2_co0 = new RooRealVar("bkg2_co0","", 3.86180e-01); RooRealVar* bkg2_co1 = new RooRealVar("bkg2_co1","", 9.49975e-01); RooRealVar* bkg2_flau = new RooRealVar("bkg2_flau","",7.28332e-01); RooRealVar* bkg2_meanlandau = new RooRealVar("bkg2_meanlandau","",1.56581e+00); RooRealVar* bkg2_sigmalandau = new RooRealVar("bkg2_sigmalandau","",5.51089e-01); RooLandau bkg2_landau("bkg2_landau", "bkg2_landau", *Psi1To2Significance, *bkg2_meanlandau, *bkg2_sigmalandau); RooChebychev bkg2_polyshape("bkg2_polyshape","",*Psi1To2Significance,RooArgList(*bkg2_co0,*bkg2_co1)); RooAddPdf bkg2_distT("bkg2_distT","", RooArgList(bkg2_landau,bkg2_polyshape),*bkg2_flau); RooProdPdf bkg2_model("bkg2_model","",RooArgList(bkg_jpsi2mass_Pol,bkg_jpsi1mass_Pol,bkg2_CT1,bkg2_distT)); ///////////////////////////////////////////// RooRealVar nsig("nsig","number of signal events",700,1,5000); RooRealVar nBbkg("nBbkg","number of B background events",1000,1,5000); RooRealVar nbkg("nbkg","number of background events",200,1,5000); RooRealVar nbkg2("nbkg2","number of background events",200,1,5000); RooAddPdf model("model","model",RooArgList(sig_model,Bbkg_model,bkg_model,bkg2_model),RooArgList(nsig,nBbkg,nbkg,nbkg2)); std::cout << "import model" << std::endl; ws->import(model); std::cout << "import data" << std::endl; ws->import(*data); cout << "data entries: " << data->numEntries() << endl; // fitting dY with SPS and DPS RooRealVar* m_dY = new RooRealVar("m_dY","",3.11781e+00); RooRealVar* w_dY = new RooRealVar("w_dY","",4.99424e-01); /* RooRealVar* p0_dY = new RooRealVar("p0_dY","",-8.06009e-01,-1.,1.); RooRealVar* p1_dY = new RooRealVar("p1_dY","",3.19965e-01,-1.,1.); RooRealVar* p2_dY = new RooRealVar("p2_dY","",-4.41787e-02,-1.,1.); */ RooRealVar* p0_dY = new RooRealVar("p0_dY","",-82.9767/3182.94); RooRealVar* p1_dY = new RooRealVar("p1_dY","",-61.3831/3182.94); RooRealVar* frac_dY = new RooRealVar("frac_dY","",1.61012e-01); RooGaussian g_dY("g_dY"," ",*Psi1To2_dY,*m_dY,*w_dY); // RooPolynomial pol_dY("pol_dY"," ",*Psi1To2_dY,RooArgList(*p0_dY,*p1_dY,*p2_dY)); // RooAddPdf model_DPS("model_DPS"," ",RooArgList(g_dY,pol_dY),*frac_dY); // RooPolynomial model_DPS("model_DPS"," ",*Psi1To2_dY,RooArgList(*p0_dY,*p1_dY,*p2_dY)); RooPolynomial model_DPS("model_DPS"," ",*Psi1To2_dY,RooArgList(*p0_dY,*p1_dY)); // RooPolynomial model_DPS("model_DPS"," ",*Psi1To2_dY,RooArgList(*p0_dY)); RooRealVar* Rm_dY = new RooRealVar("Rm_dY"," " , -5.82342e-01); RooRealVar* Rw_dY = new RooRealVar("Rw_dY"," " , 7.35732e-01); RooRealVar* lambda_dY = new RooRealVar("lambda_dY"," " , 3.26722e-01); RooGaussModel res_dY("res_dY","",*Psi1To2_dY,*Rm_dY,*Rw_dY); RooDecay model_SPS("model_SPS","",*Psi1To2_dY,*lambda_dY,res_dY,RooDecay::SingleSided); RooRealVar nsigDPS("nsigDPS","number of signal events",300,1,500); RooRealVar nsigSPS("nsigSPS","number of signal events",200,1,500); RooAddPdf model_dY("model_dY","model_dY",RooArgList(model_DPS,model_SPS),RooArgList(nsigDPS,nsigSPS)); std::cout << "import model for dY fitting" << std::endl; ws->import(model_dY); }