void decon_ind(Int_t chan = 221){ TFile *file = new TFile("Run_00009188.root"); TH2* h1 = (TH2*)file->Get(Form("Ind_%d",chan)); TH2* h3 = (TH2*)h1->Clone("h3"); TH2* h4 = (TH2*)h1->Clone("h4"); h3->Reset(); h4->Reset(); gStyle->SetOptStat(0); TCanvas *c1 = new TCanvas("c1","c1",800,800); c1->Divide(2,2); c1->cd(1); h1->Draw("COLZ"); h1->GetZaxis()->SetRangeUser(-80,80); h1->GetXaxis()->SetRangeUser(0,3000); h1->SetTitle("Original Induction"); h3->SetTitle("Noise Removed Induction"); Int_t max_bin = h1->GetMaximumBin(); Float_t max = h1->GetBinContent(max_bin); Int_t min_bin = h1->GetMinimumBin(); Float_t min = h1->GetBinContent(min_bin); TH1F *h2 = new TH1F("h2","h2",Int_t(max - min+2), min-1, max+1); //cout << h1->GetXaxis()->GetNbins() << " " << h1->GetYaxis()->GetNbins() << endl; for (Int_t i=0;i!=h1->GetXaxis()->GetNbins();i++){ h2->Reset(); for (Int_t j=0;j!=h1->GetYaxis()->GetNbins();j++){ h2->Fill(h1->GetBinContent(i,j)); } Double_t xq = 0.5; Double_t par[10]; h2->GetQuantiles(1,&par[0],&xq); for (Int_t j=0;j!=h1->GetYaxis()->GetNbins();j++){ h3->SetBinContent(i,j,h1->GetBinContent(i,j)-par[0]); } //cout << par[0] << endl; } c1->cd(2); h3->Draw("COLZ"); h3->GetXaxis()->SetRangeUser(0,3000); // do deconvolution for every channel ... c1->cd(3); TFile *file1 = new TFile("ave_res.root"); TH1F *hva = (TH1F*)file1->Get("hu"); TGraph *gva = new TGraph(); for (Int_t i=0;i!=hva->GetNbinsX();i++){ Double_t x = hva->GetBinCenter(i+1); Double_t y = hva->GetBinContent(i+1) * (-1); gva->SetPoint(i,x,y); } TH1F *h2t = new TH1F("h2t","h2t",h1->GetXaxis()->GetNbins(),0,h1->GetXaxis()->GetNbins()); TH1F *h2r = (TH1F*)h2t->Clone("h2r"); h2r->Reset(); for (Int_t i=0;i!=h2r->GetNbinsX();i++){ Double_t x = h2r->GetBinCenter(i+1)/2.-50; h2r->SetBinContent(i+1,gva->Eval(x)); } TF1 *filter_v = new TF1("filter_v","(x>0.0)*gaus*exp(-0.5*pow(x/[3],[4]))"); double par1[5]={1.74/0.941034, 1.46, 1.33, 0.23, 4.89}; filter_v->SetParameters(par1); TVirtualFFT::SetTransform(0); TH1 *hmr = 0; TH1 *hpr = 0; Int_t n = 8192; TVirtualFFT *ifft = TVirtualFFT::FFT(1,&n,"C2R M K"); Double_t value_re[8192]; Double_t value_im[8192]; TH1 *fb = 0; TH1 *hmv = 0; TH1 *hpv = 0; for (Int_t k=0;k!=h1->GetYaxis()->GetNbins();k++){ // for (Int_t k=33;k!=33+1;k++){ h2t->Reset(); for (Int_t i=0;i!=8192;i++){ float content = h3->GetBinContent(i+1,k+1); h2t->SetBinContent(i+1,content); } h2t->Draw(); cout << h2t->Integral(500,1500) << endl; //cout << max << " " << min << endl; hmr = 0; hpr = 0; hmr = h2r->FFT(hmr,"MAG"); hpr = h2r->FFT(hpr,"PH"); hmv = 0; hpv = 0; hmv = h2t->FFT(hmv,"MAG"); hpv = h2t->FFT(hpv,"PH"); for (Int_t j=0;j!=8192;j++){ Double_t freq; if ( j < 8192/2.){ freq = j/8192.*2.; }else{ freq = (8192-j)/8192.*2.; } Double_t rho; if (hmr->GetBinContent(j+1)!=0){ rho = hmv->GetBinContent(j+1) / hmr->GetBinContent(j+1)*filter_v->Eval(freq); }else{ rho = 0; } Double_t phi = hpv->GetBinContent(j+1) - hpr->GetBinContent(j+1); value_re[j] = rho*cos(phi)/8192.; value_im[j] = rho*sin(phi)/8192.; } ifft->SetPointsComplex(value_re,value_im); ifft->Transform(); fb = 0; fb = TH1::TransformHisto(ifft,fb,"Re"); Double_t sum = 0; Double_t sum1 = 0; for (Int_t i=5000;i!=8000;i++){ sum += fb->GetBinContent(i+1); sum1 += 1; } for (Int_t i=0;i!=8192;i++){ Int_t binnum = i+1+104; if (binnum > 8192) binnum -=8192; h4->SetBinContent(binnum,k+1,fb->GetBinContent(i+1)-sum/sum1); } } h3->GetZaxis()->SetRangeUser(0,100); c1->cd(3); h4->RebinX(4); for (Int_t i=0;i!=h4->GetXaxis()->GetNbins();i++){ for (Int_t j=0;j!=h4->GetYaxis()->GetNbins();j++){ Double_t content1 = h4->GetBinContent(i+1,j+1); // if (content1 <1) // h4->SetBinContent(i+1,j+1,1); } } h4->Draw("COLZ"); h4->GetZaxis()->SetRangeUser(0,30); h4->GetXaxis()->SetRangeUser(0,3000); c1->cd(4); TH2 *h5 = (TH2*)file->Get(Form("Col_%d",chan)); h5->Draw("COLZ"); h5->GetZaxis()->SetRangeUser(0,300); h5->GetXaxis()->SetRangeUser(0,3000); c1->cd(2); for (Int_t i=0;i!=h3->GetXaxis()->GetNbins();i++){ for (Int_t j=0;j!=h3->GetYaxis()->GetNbins();j++){ Double_t content1 = h3->GetBinContent(i+1,j+1); content1 = fabs(content1); h3->SetBinContent(i+1,j+1,content1); } } h3->Draw("COLZ"); h4->SetTitle("Deconvoluted Induction"); h5->SetTitle("Collection Raw"); // c1->cd(1); // h2r->Draw(); // c1->cd(4); // Double_t sum = 0; // Double_t sum1 = 0; // for (Int_t i=4000;i!=7000;i++){ // sum += fb->GetBinContent(i+1); // sum1 += 1; // } // TH1F *h2k = (TH1F*)h2t->Clone("h2k"); // for (Int_t j=0;j!=8192;j++){ // h2k->SetBinContent(j+1,fb->GetBinContent(j+1)-sum/sum1); // } // h2k->Rebin(4); // h2k->Draw(); }
int ntuAnalyzer(std::string fileName) { setGlobalStyle(); //############################### //## run274200 ## unsigned int HT250Calo = 9; //index of DST_HT250_CaloScouting_v old:1 ref:9 float HT250Calo_rate = 1928; unsigned int HT410PF = 7; //index of DST_HT410_PFScouting_v old:3 ref:7 float HT410PF_rate = 294; unsigned int MJJ200Calo = 12; //index of DST_DiCaloWideJetMass200_CaloScouting_v unsigned int HTT200 = 0; //index if L1_HTT200 unsigned int HTT240 = 1; //index if L1_HTT240 unsigned int HTT270 = 2; //index if L1_HTT270 unsigned int HTT280 = 3; //index if L1_HTT280 unsigned int DoubleJetC100 = 7; //index if L1_DoubleJetC100 unsigned int DoubleJetC112 = 8; //index if L1_DoubleJetC112 unsigned int DoubleIsoTau28er = 11; //index if L1_DoubleJetC112 float instLumi = 0.4; //E34 float targetLumi = 1; //E34 float lumiScaleFactor = targetLumi/instLumi; float PDRate = 59300; //unprescaled rate of HLTPhysics accordingly to: https://cmswbm2.web.cern.ch/cmswbm2/cmsdb/servlet/DatasetSummary?RUN=274200 and prescale of 9000 unsigned int L1scenario = HTT240; //############################### TChain* tt = new TChain("MyAnalysis/HLTree"); tt->Add(fileName.c_str()); //set branches TBranch* b_lumi; TBranch* b_caloMjj; TBranch* b_PFMjj; TBranch* b_hltAccept; TBranch* b_l1Accept; TBranch* b_l1Names; TBranch* b_caloJet1Pt; TBranch* b_caloJet2Pt; TBranch* b_caloJet1Eta; TBranch* b_caloJet2Eta; TBranch* b_caloDeltaEta; TBranch* b_PFJet1Pt; TBranch* b_PFJet2Pt; TBranch* b_PFJet1Eta; TBranch* b_PFJet2Eta; TBranch* b_PFDeltaEta; int lumi = 0; float caloMjj = 0; float PFMjj = 0; float caloJet1Pt_ = 0; float caloJet2Pt_ = 0; float caloJet1Eta_ = -999; float caloJet2Eta_ = -999; float caloDeltaEta_ = -999; float PFJet1Pt_ = 0; float PFJet2Pt_ = 0; float PFJet1Eta_ = -999; float PFJet2Eta_ = -999; float PFDeltaEta_ = -999; std::vector<int>* hltAccept = 0; std::vector<int>* l1Accept = 0; std::vector<string>* l1Names = 0; tt->SetBranchAddress("lumi", &lumi, &b_lumi); tt->SetBranchAddress("caloMjj", &caloMjj, &b_caloMjj); tt->SetBranchAddress("PFMjj", &PFMjj, &b_PFMjj); tt->SetBranchAddress("caloJet1Pt", &caloJet1Pt_, &b_caloJet1Pt); tt->SetBranchAddress("caloJet2Pt", &caloJet2Pt_, &b_caloJet2Pt); tt->SetBranchAddress("caloJet1Eta", &caloJet1Eta_, &b_caloJet1Eta); tt->SetBranchAddress("caloJet2Eta", &caloJet2Eta_, &b_caloJet2Eta); tt->SetBranchAddress("caloDeltaEta", &caloDeltaEta_, &b_caloDeltaEta); tt->SetBranchAddress("PFJet1Pt", &PFJet1Pt_, &b_PFJet1Pt); tt->SetBranchAddress("PFJet2Pt", &PFJet2Pt_, &b_PFJet2Pt); tt->SetBranchAddress("PFJet1Eta", &PFJet1Eta_, &b_PFJet1Eta); tt->SetBranchAddress("PFJet2Eta", &PFJet2Eta_, &b_PFJet2Eta); tt->SetBranchAddress("PFDeltaEta", &PFDeltaEta_, &b_PFDeltaEta); tt->SetBranchAddress("hltAccept", &hltAccept, &b_hltAccept); tt->SetBranchAddress("l1Accept", &l1Accept, &b_l1Accept); tt->SetBranchAddress("l1Names", &l1Names, &b_l1Names); int nentries = tt->GetEntries(); std::cout << "Number of entries: " << nentries << std::endl; //book graphs and plots float min = 0.; float max = 1000.; int nBins = 20; TF1* f1 = new TF1("f1","[0]*TMath::Erf((x-[1])/[2])-[0]*TMath::Erf((-x-[1])/[2])",min,max); f1->SetParameters(0.5,350,40); f1->FixParameter(0,0.5); f1->SetLineWidth(2.); f1->SetLineColor(kRed); TF1* f2 = (TF1*)f1->Clone("f2"); f2->SetParameters(0.5,150,10); f2->SetLineColor(kBlack); TH1F* caloMjjSpectrum = new TH1F("caloMjjSpectrum","caloMjjSpectrum",nBins,min,max); TH1F* PFMjjSpectrum = new TH1F("PFMjjSpectrum","PFMjjSpectrum",nBins,min,max); TEfficiency* mjj450_eff = new TEfficiency("mjj450_eff","mjj450_eff",nBins,min,max); mjj450_eff->SetMarkerColor(kRed); mjj450_eff->SetLineColor(kRed); mjj450_eff->SetLineWidth(2); mjj450_eff->SetTitle("turnOn;Mjj [GeV]"); TEfficiency* mjj200_eff = new TEfficiency("mjj200_eff","mjj200_eff",nBins,min,max); mjj200_eff->SetLineWidth(2); mjj200_eff->SetTitle("turnOn;Mjj [GeV]"); TEfficiency* pf410_eff = new TEfficiency("pf410_eff","pf410_eff",nBins,min,max); pf410_eff->SetMarkerColor(kOrange+1); pf410_eff->SetLineColor(kOrange+1); TEfficiency* calo250_eff = new TEfficiency("calo250_eff","calo250_eff",nBins,min,max); calo250_eff->SetMarkerColor(kBlue); calo250_eff->SetLineColor(kBlue); TEfficiency* HTT240_eff = new TEfficiency("HTT240_eff","HTT240_eff",nBins,min,max); HTT240_eff->SetMarkerColor(kGreen+2); HTT240_eff->SetLineColor(kGreen+2); TH1F* l1 = new TH1F("l1","l1",14,0.,14.); TH1F* l2 = new TH1F("l2","l2",14,0.,14.); //loop for (Long64_t jentry=0; jentry<nentries;++jentry) { tt->GetEntry(jentry); //remove low rate lumis. //see: https://cmswbm2.web.cern.ch/cmswbm2/cmsdb/servlet/ChartHLTTriggerRates?RUNID=274200&PATHID=2043408&LSLENGTH=23.31040958&TRIGGER_PATH=DST_HT250_CaloScouting_v2 //if(lumi > 539 && lumi < 553) continue; //l1 and hlt rates for(unsigned int ii=0; ii<l1Names->size(); ++ii) if (l1Accept->at(ii)==1) l1->Fill(ii); //analysis cuts needed to compare to the analysis //calo analysis if (caloJet1Pt_ > 60. && caloJet2Pt_ > 30. && fabs(caloJet1Eta_) < 2.5 && fabs(caloJet2Eta_) < 2.5 && caloDeltaEta_ < 1.3) { caloMjjSpectrum->Fill(caloMjj); mjj200_eff->Fill((caloMjj>200 && l1Accept->at(L1scenario)==1) || hltAccept->at(HT250Calo)==1, caloMjj); calo250_eff->Fill((hltAccept->at(HT250Calo)==1 && l1Accept->at(L1scenario)==1), caloMjj); //references HTT240_eff->Fill(l1Accept->at(HTT240)==1, caloMjj); //l1 and hlt rates for(unsigned int ii=0; ii<l1Names->size(); ++ii) if (l1Accept->at(ii)==1) l2->Fill(ii); } //PF analysis if (PFJet1Pt_ > 60. && PFJet2Pt_ > 30. && fabs(PFJet1Eta_) < 2.5 && fabs(PFJet2Eta_) < 2.5 && PFDeltaEta_ < 1.3) { PFMjjSpectrum->Fill(PFMjj); mjj450_eff->Fill((caloMjj>450 && l1Accept->at(L1scenario)==1) || hltAccept->at(HT410PF)==1, PFMjj); pf410_eff->Fill((hltAccept->at(HT410PF)==1 && l1Accept->at(L1scenario)==1), PFMjj); } } mjj450_eff->Fit(f1,"r"); mjj200_eff->Fit(f2,"r"); caloMjjSpectrum->Scale(1./caloMjjSpectrum->GetBinContent(caloMjjSpectrum->GetMaximumBin())); PFMjjSpectrum->Scale(1./PFMjjSpectrum->GetBinContent(PFMjjSpectrum->GetMaximumBin())); TLegend* leg0 = new TLegend(0.62, 0.78, 0.83, 0.89); leg0->AddEntry(mjj200_eff,"MJJ200Calo || HT250Calo","L"); leg0->AddEntry(calo250_eff,"HT250_Calo","P"); leg0->AddEntry(HTT240_eff,"HTT240","P"); TLegend* leg1 = new TLegend(0.62, 0.78, 0.83, 0.89); leg1->AddEntry(mjj450_eff,"MJJ450PF || HT410PF","L"); leg1->AddEntry(pf410_eff,"HT410_PF","P"); TCanvas* c1 = new TCanvas(); mjj200_eff->Draw(); calo250_eff->Draw("sames"); HTT240_eff->Draw("sames"); caloMjjSpectrum->Draw("L,sames"); leg0->Draw("sames"); TCanvas* c2 = new TCanvas(); mjj450_eff->Draw(); pf410_eff->Draw("sames"); PFMjjSpectrum->Draw("L,sames"); leg1->Draw("sames"); TCanvas* c3 = new TCanvas(); //l1->Scale(PDRate/nentries); for(unsigned int ii=0; ii<l1Names->size(); ++ii) l1->GetXaxis()->SetBinLabel(ii+1,l1Names->at(ii).c_str()); //l1->GetYaxis()->SetTitle("L1 Rate @4E33 [Hz]"); l1->SetMaximum(l1->GetMaximum()+200); l2->SetLineColor(kRed); l1->Draw(); l2->Draw("same"); c3->Update(); // TGaxis *l1axis = new TGaxis(gPad->GetUxmax(),gPad->GetUymin(),gPad->GetUxmax(), gPad->GetUymax(), // l1->GetMinimum()*lumiScaleFactor, // l1->GetMaximum()*lumiScaleFactor,510,"+L"); // c2->SetTicky(0); // l1axis->SetLineColor(kRed); // l1axis->SetLabelColor(kRed); // l1axis->SetTextColor(kRed); // l1axis->SetTitleOffset(1.3); // l1axis->SetLabelSize(0.03); // l1axis->SetTitle("L1 Rate @1E34 [Hz]"); // l1axis->Draw(); //return 0; //############################################## //############################################## //book graphs and plots TGraphErrors* totRateVsCut = new TGraphErrors(); totRateVsCut->SetMinimum(0); TGraphErrors* pureRateVsCut450 = new TGraphErrors(); TGraphErrors* pureRateVsCut280 = new TGraphErrors(); //loops int bin = 0; for (int cut = 350; cut < 500; cut=cut+10) { int mjjPassed = 0; int HT250Calo_Passed = 0; int excl410_passed = 0; int excl250_passed = 0; for (Long64_t jentry=0; jentry<nentries;++jentry) { tt->GetEntry(jentry); if (hltAccept->at(HT250Calo) == 1) ++HT250Calo_Passed; //if (caloMjj > cut && !hltAccept->at(HT410PF)) if (caloMjj > cut && l1Accept->at(L1scenario) == 1 && hltAccept->at(HT410PF)==0) ++excl410_passed; if (caloMjj > cut && l1Accept->at(L1scenario)==1 && hltAccept->at(HT250Calo)==0) ++excl250_passed; if (caloMjj > cut && l1Accept->at(L1scenario)==1) ++mjjPassed; // if (hltAccept->at(HT250Calo) == 0 && mjj > cut) // std::cout << "ref trigger doesn't completely cover cut at " << cut << std::endl; } // float mjjTotalRate = (float)mjjPassed/(float)HT250Calo_Passed*HT250Calo_rate; // float mjjPureRate = (float)exclPassed/(float)HT250Calo_Passed*HT250Calo_rate; float sigmaMjjPassed = sqrt((float)mjjPassed); float sigmaNentries = sqrt((float)nentries); float sigmaExcl410_passed = sqrt((float)excl410_passed); float sigmaExcl250_passed = sqrt((float)excl250_passed); float mjjTotalRate = (float)mjjPassed/(float)nentries*PDRate; float mjjTotalRateE = PDRate*sqrt(pow((sigmaMjjPassed/nentries),2)+pow((sigmaNentries*mjjPassed/nentries/nentries),2)); float mjj450_PureRate = (float)excl410_passed/(float)nentries*PDRate; float mjj450_PureRateE = PDRate*sqrt(pow((sigmaExcl410_passed/nentries),2)+pow((sigmaNentries*excl410_passed/nentries/nentries),2)); float mjj280_PureRate = (float)excl250_passed/(float)nentries*PDRate; float mjj280_PureRateE = PDRate*sqrt(pow((sigmaExcl250_passed/nentries),2)+pow((sigmaNentries*excl250_passed/nentries/nentries),2)); totRateVsCut->SetPoint(bin,cut,mjjTotalRate); totRateVsCut->SetPointError(bin,0.,mjjTotalRateE); pureRateVsCut450->SetPoint(bin,cut,mjj450_PureRate); pureRateVsCut450->SetPointError(bin,0.,mjj450_PureRateE); pureRateVsCut280->SetPoint(bin,cut,mjj280_PureRate); pureRateVsCut280->SetPointError(bin,0.,mjj280_PureRateE); ++bin; } //plotting and styling TLegend* leg = new TLegend(0.62, 0.78, 0.83, 0.89); leg->AddEntry(totRateVsCut,"total rate","P"); leg->AddEntry(pureRateVsCut450,"pure rate wrt HT410PF","P"); leg->AddEntry(pureRateVsCut280,"pure rate wrt HT250Calo","P"); totRateVsCut->SetTitle("Rate Ref"); totRateVsCut->GetXaxis()->SetTitle("Mjj cut threshold [GeV]"); totRateVsCut->GetYaxis()->SetTitle("Rate @4E33 [Hz]"); pureRateVsCut450->SetMarkerColor(kRed); pureRateVsCut450->SetLineColor(kRed); pureRateVsCut280->SetMarkerColor(kOrange+1); pureRateVsCut280->SetLineColor(kOrange+1); TCanvas* c4 = new TCanvas(); c4->cd(); totRateVsCut->Draw("AP"); pureRateVsCut450->Draw("P,sames"); pureRateVsCut280->Draw("P,sames"); leg->Draw("sames"); c4->Update(); TGaxis *axis = new TGaxis(gPad->GetUxmax(),gPad->GetUymin(),gPad->GetUxmax(), gPad->GetUymax(), (totRateVsCut->GetYaxis()->GetBinLowEdge(1))*lumiScaleFactor, (totRateVsCut->GetYaxis()->GetBinLowEdge(totRateVsCut->GetYaxis()->GetNbins())+totRateVsCut->GetYaxis()->GetBinWidth(1))*lumiScaleFactor,510,"+L"); c4->SetTicky(0); axis->SetLineColor(kRed); axis->SetLabelColor(kRed); axis->SetTextColor(kRed); axis->SetTitleOffset(1.3); axis->SetLabelSize(0.03); axis->SetTitle("Rate @1E34 [Hz]"); axis->Draw(); return 0; }
void analysis() { Int_t nbins = 800; Int_t j; char name[20]; char title[100]; TH1F *HistoEvent[2214]; for (Int_t z=0;z<2214;z++) { sprintf(name,"HistoEvent%d",z-1); sprintf(title,"Event%d Histo", z-1); HistoEvent[z] = new TH1F(name,title,nbins, -0.1, 159.9); } TH1F *NewHistoEvent[2214]; for (Int_t z=0;z<2214;z++) { sprintf(name,"NewHistoEvent%d",z-1); sprintf(title,"Event%d Histo", z-1); NewHistoEvent[z] = new TH1F(name,title,nbins, -0.1, 159.9); } TH1F *NewHistoEventFFT[2214]; for (Int_t z=0;z<2214;z++) { sprintf(name,"NewHistoEventFFT%d",z-1); sprintf(title,"Event%d Histo", z-1); NewHistoEventFFT[z] = new TH1F(name,title,nbins, 0, 5); } Double_t mean; Double_t rms; Double_t meansum = 0; Double_t count = 0; Double_t meanrms = 0; TFile f("/home/marko/H4Analysis/ntuples/analysis_4443.root"); //ntuple generated by H4Analysis tool TFile f1("/home/marko/H4Analysis/ntuples/analysis_3905.root"); TFile f2("/home/marko/Desktop/TB Timing Res/NormalizedSignalNoise.root", "read"); TH1F* BestSignal = (TH1F*) f2.Get("BetterSignal"); TFile outputfile("myoutput.root", "recreate"); TCanvas* TimeandFreq = new TCanvas("TimeandFreq","Time and Frequency",1500,900); TCanvas* Freq = new TCanvas("Freq","Frequency",800,1200); TCanvas* TimeSignal = new TCanvas("TimeSignal","Pure Signal",800,1200); TimeandFreq->Divide(2,2); TTree* h4 = (TTree*) f.Get("h4"); TTree* h4_2 = (TTree*) f1.Get("h4"); TString plot; TString cut; TH2F* WavePulse = new TH2F ("WavePulse", "Wave Pulse", nbins, -0.1, 159.9, 850, -50, 800); TH2F* NoisePulse = new TH2F ("NoisePulse", "Noise", nbins, -0.1, 159.9, 100, -50, 50); TH1F* PulseTime = new TH1F ("PulseTime", "Original Wave Pulse", nbins, -0.1, 159.9); //nanoseconds TH2F* TempHisto = new TH2F ("TempHisto", "Temp Histo", nbins, -0.1, 159.9, 1000, -15, 15); //nanoseconds h4->Draw("WF_val:WF_time>>WavePulse", "WF_ch==2 && event==1 && spill==1"); h4_2->Draw("WF_val:WF_time>>NoisePulse","WF_ch==APD1 && amp_max[APD3]<25 && b_rms[APD3]<5. && charge_tot[APD3]<20000 && amp_max[APD5]<25 && b_rms[APD5]<5. && amp_max[APD6]<25 && b_rms[APD6]<5. && amp_max[APD4]<25 && b_rms[APD4]<5. && amp_max[SiPM1]<20 && amp_max[SiPM2]<20 && amp_max[APD1]<40 && amp_max[APD2]<40 && b_rms[APD1]<5. && b_rms[APD2]<5. && WF_time<160"); for (Int_t i=0; i<nbins; i++) { for (Int_t k=0; k<4096; k++) { if (WavePulse->GetBinContent(i+1, k) != 0) { PulseTime->SetBinContent(i+1,k-50); } } } TH1F *NoiseTime = new TH1F ("NoiseTime", "Noise", nbins, -0.1, 159.9); for (Int_t i=0; i<nbins; i++) { for (Int_t k=0; k<4096; k++) { if (NoisePulse->GetBinContent(i+1, k) != 0) { NoiseTime->SetBinContent(i+1,k-62.9087); } } } //TH1F* NormNoiseFFT = new TH1F ("NormNoiseFFT", "Normalized Noise FFT", nbins, 0, 5); //TStopwatch t; //t.Start(); //1 hour runtime //for (j=10;j<20;j++) { // plot = "WF_val:WF_time>>TempHisto"; // cut = "WF_ch==APD1 && amp_max[APD3]<25 && b_rms[APD3]<5. && charge_tot[APD3]<20000 && amp_max[APD5]<25 && b_rms[APD5]<5. && amp_max[APD6]<25 && b_rms[APD6]<5. && amp_max[APD4]<25 && b_rms[APD4]<5. && amp_max[SiPM1]<20 && amp_max[SiPM2]<20 && amp_max[APD1]<40 && amp_max[APD2]<40 && b_rms[APD1]<5. && b_rms[APD2]<5. && WF_time<160 && event=="; // cut += j; // h4_2->Draw(plot, cut, "goff"); // if (TempHisto->GetMaximum() == 0) { // delete HistoEvent[j+1]; // continue; // } // for (Int_t i=0; i<nbins; i++) { // for (Int_t k=0; k<1000; k++) { // if (TempHisto->GetBinContent(i+1, k) != 0) { // HistoEvent[j+1]->SetBinContent(i+1,k*0.03-15); // } // } // } // mean = TempHisto->GetMean(2); // rms = TempHisto->GetRMS(2); // for (Int_t q=0;q<nbins;q++) { // NewHistoEvent[j+1]->SetBinContent(q+1, HistoEvent[j+1]->GetBinContent(q+1)-mean); // } // NewHistoEvent[j+1]->Scale(1/rms); // NewHistoEvent[j+1]->FFT(NewHistoEventFFT[j+1], "MAG"); // NormNoiseFFT->Add(NormNoiseFFT, NewHistoEventFFT[j+1]); // TempHisto->Write(); // NewHistoEvent[j+1]->Write(); // NewHistoEventFFT[j+1]->Write(); // cout << "Event " << j << ", Mean = " << mean << ", RMS = " << rms << endl; // count += 1; //} //NormNoiseFFT->Scale(1/count); //NormNoiseFFT->Write(); //t.Stop(); //t.Print(); new TFile("/home/marko/H4Analysis/ntuples/analysis_4443.root"); // ignore this reloading of the same file, it is required or else the plots do not show up (when I tried) TimeandFreq->cd(1); PulseTime->GetXaxis()->SetTitle("Time (ns)"); PulseTime->GetYaxis()->SetTitle("Amplitude"); PulseTime->DrawClone(); //Wave Pulse in Time domain TimeandFreq->cd(2); TH1F* PulseFreq = new TH1F ("PulseFreq", "Pulse FFT", nbins, 0, 5); TH1F* PulsePhase = new TH1F ("PulsePhase", "Pulse Phase", nbins, -0.1, 799.9); PulseTime->FFT(PulseFreq, "MAG"); PulseTime->FFT(PulsePhase, "PH"); PulseFreq->SetLineColor(kRed); PulseFreq->GetXaxis()->SetTitle("Frequency (GHz)"); PulseFreq->GetYaxis()->SetTitle("Amplitude"); PulseFreq->DrawClone(); //Wave Pulse in Frequency domain gPad->SetLogy(); TimeandFreq->cd(3); NoiseTime->GetXaxis()->SetTitle("Time (ns)"); NoiseTime->GetYaxis()->SetTitle("Amplitude"); NoiseTime->DrawClone(); // Noise from pedestal in Time domain TimeandFreq->cd(4); TH1F* NoiseFreq = new TH1F ("NoiseFreq", "Noise FFT", nbins, 0, 5); NoiseTime->FFT(NoiseFreq, "MAG"); NoiseFreq->GetXaxis()->SetTitle("Frequency (GHz)"); NoiseFreq->GetYaxis()->SetTitle("Amplitude"); NoiseFreq->Draw(); // Noise from pedestal in Frequency domain gPad->SetLogy(); Freq->Divide(1,3); Freq->cd(1); PulseFreq->DrawClone(); gPad->SetLogy(); Freq->cd(2); NoiseFreq->DrawClone(); gPad->SetLogy(); Freq->cd(3); PulseFreq->SetTitle("Pulse and Noise FFT Comparison"); PulseFreq->Draw(); NoiseFreq->Draw("same"); gPad->SetLogy(); TH1F* UnscaledSignalFreq = new TH1F ("UnscaledSignalFreq", "Unscaled Signal Frequency", nbins, -0.1, 799.9); for (Int_t l=0; l<nbins; l++) { UnscaledSignalFreq->SetBinContent(l+1, (PulseFreq->GetBinContent(l+1)-NoiseFreq->GetBinContent(l+1))/PulseFreq->GetBinContent(l+1)); } TH1F* SignalFreq = new TH1F ("SignalFreq", "Signal Frequency", nbins, 0, 799.9); for (Int_t m=0; m<nbins; m++) { SignalFreq->SetBinContent(m+1, UnscaledSignalFreq->GetBinContent(m+1)*PulseFreq->GetBinContent(m+1)); } Double_t *re_full = new Double_t[nbins]; Double_t *im_full = new Double_t[nbins]; for (Int_t n=0; n<nbins; n++) { (re_full)[n]=(SignalFreq->GetBinContent(n+1)*cos(PulsePhase->GetBinContent(n+1))); (im_full)[n]=(SignalFreq->GetBinContent(n+1)*sin(PulsePhase->GetBinContent(n+1))); } TVirtualFFT *invFFT = TVirtualFFT::FFT(1, &nbins, "C2R M K"); invFFT->SetPointsComplex(re_full, im_full); invFFT->Transform(); TH1 *Signal = 0; Signal = TH1::TransformHisto(invFFT,Signal,"Re"); Signal->SetTitle("Recovered Signal 'S'"); TH1F* BetterSignal = new TH1F ("BetterSignal", "Recovered Signal", nbins, -0.1, 159.9); for (Int_t p=0; p<nbins; p++) { BetterSignal->SetBinContent(p+1, Signal->GetBinContent(p+1)/nbins); } TimeSignal->Divide(1,2); TimeSignal->cd(1); PulseTime->DrawClone(); //Original Wave Pulse TimeSignal->cd(2); BetterSignal->GetXaxis()->SetTitle("Time (ns)"); BetterSignal->GetYaxis()->SetTitle("Amplitude"); BetterSignal->SetLineColor(kRed); //BetterSignal->Draw(); // Recovered Wave Pulse with decreased contribution from background noise BestSignal->SetLineColor(kGreen); BestSignal->DrawClone("same"); PulseTime->DrawClone("same"); }
void makeTable(TString myVar, TString myCut, TString myName, TString myAxisNameX, TString myAxisNameY, vector<const Sample*>& listOfSamples, vector<const Sample*> listOfDatasets, TString inFileName, bool isBlind, bool isLog, int nBins, float xLow, float xHigh, float* xlowVec) { // prepare the input file TFile* infile = new TFile(inFileName, "READ"); infile -> cd(); // prepare the necessary for the scale factor estimation float defScaleFactor = 1.3; float newScaleFactor = 1.; float varScaleFactor = 1.; float nBkg = 0; float nBkgErrSq = 0; float nSig = 0; float nSigErrSq = 0; // prepare the stack THStack *hs = new THStack("hs",""); // prepare the histos pointers TH1F* hist[20]; // prepare the tree pointers TTree* tree[20]; // prepare the legend TLegend* leg = new TLegend(.7485,.7225,.9597,.9604); leg->SetFillColor(0); // prepare the colors Int_t col[20] = {46,2,12,5,3,4,9,7,47,49,49,50,51,52,53,54,55,56,57,58}; // prepare the Y axis lable if (xlowVec != 0) myAxisNameY = "Events/" + myAxisNameY; else { float binWidth = (xHigh-xLow)/nBins; TString tempString; tempString.Form("%.2f ",binWidth); myAxisNameY = "Events/" + tempString + myAxisNameY; } // prepare the legend strings vector<TString> theLegends; // loop through the datasets and produce the plots TH1F* hdata; //variable bin histo if (xlowVec != 0) hdata = new TH1F("hdata","",nBins,xlowVec); //fixed bin histo else hdata = new TH1F("hdata","",nBins,xLow,xHigh); TTree* treedata[20]; for (UInt_t iDatas=0; iDatas < listOfDatasets.size(); iDatas++) { //get the tree treedata[iDatas] = (TTree*) infile -> Get(listOfDatasets.at(iDatas)->Name()->Data()); //fill the histogram if ( iDatas == 0 ) treedata[iDatas] -> Draw(myVar + " >> hdata","hlt_weight*evt_weight*kf_weight*pu_weight" + myCut,"goff"); else treedata[iDatas] -> Draw(myVar + " >>+ hdata","hlt_weight*evt_weight*kf_weight*pu_weight" + myCut,"goff"); if ( iDatas == 0 ) leg -> AddEntry(hdata, "DATA (19.8 fb^{-1})", "pl"); }//end loop on datasets if (xlowVec != 0) { for (int iBin = 1; iBin <= nBins; iBin++) hdata->SetBinError (iBin,hdata->GetBinError(iBin)/hdata->GetBinWidth(iBin)); for (int iBin = 1; iBin <= nBins; iBin++) hdata->SetBinContent(iBin,hdata->GetBinContent(iBin)/hdata->GetBinWidth(iBin)); } int theHistCounter = 0; // loop through the samples and produce the plots for (UInt_t iSample=0; iSample < listOfSamples.size(); iSample++) { //determine if the histo is first of the series bool isFirstOfSerie = (*listOfSamples.at(iSample)->Legend()).CompareTo(" "); bool isLastOfSerie = false; if (iSample == listOfSamples.size() - 1) isLastOfSerie = true; if (iSample < listOfSamples.size() - 1 && (*listOfSamples.at(iSample+1)->Legend()).CompareTo(" ") != 0) isLastOfSerie = true; //get the tree tree[iSample] = (TTree*) infile -> Get(listOfSamples.at(iSample)->Name()->Data()); //if sample first of the list create a new histogram if (isFirstOfSerie) { TString thisHistName = "h_" + *(listOfSamples.at(iSample)->Name()); //variable bin histo if (xlowVec != 0) hist[theHistCounter] = new TH1F(thisHistName,thisHistName,nBins,xlowVec); //fixed bin histo else hist[theHistCounter] = new TH1F(thisHistName,thisHistName,nBins,xLow,xHigh); hist[theHistCounter] -> Sumw2(); hist[theHistCounter] -> SetFillColor(col[theHistCounter]); hist[theHistCounter] -> SetFillStyle(1001); theLegends.push_back(*listOfSamples.at(iSample)->Legend()); cout << *listOfSamples.at(iSample)->Legend() << " "; } //fill the histogram TString thisScale = Form("%f *", *(listOfSamples.at(iSample)->Scale())); if (isFirstOfSerie) tree[iSample] -> Draw(myVar + " >> " + TString(hist[theHistCounter] -> GetName()),thisScale + "hlt_weight*evt_weight*kf_weight*pu_weight" + myCut,"goff"); else tree[iSample] -> Draw(myVar + " >>+ " + TString(hist[theHistCounter] -> GetName()),thisScale + "hlt_weight*evt_weight*kf_weight*pu_weight" + myCut,"goff"); //add the histogram to the stack if the last of the series: //either last sample or ~ sample followed by non ~ sample if (isLastOfSerie) { if (xlowVec != 0) { for (int iBin = 1; iBin <= nBins; iBin++) hist[theHistCounter]->SetBinError (iBin,hist[theHistCounter]->GetBinError(iBin)/hist[theHistCounter]->GetBinWidth(iBin)); for (int iBin = 1; iBin <= nBins; iBin++) hist[theHistCounter]->SetBinContent(iBin,hist[theHistCounter]->GetBinContent(iBin)/hist[theHistCounter]->GetBinWidth(iBin)); } hs -> Add(hist[theHistCounter]); cout << hist[theHistCounter] -> GetBinContent(1) << " +/- " << hist[theHistCounter] -> GetBinError(1) << endl; if ( listOfSamples.at(iSample)->Name()->Contains("wgptg130") ) { nSig += hist[theHistCounter] -> GetBinContent(1) ; nSigErrSq += pow(hist[theHistCounter] -> GetBinError(1),2) ; } else { nBkg += hist[theHistCounter] -> GetBinContent(1) ; nBkgErrSq += pow(hist[theHistCounter] -> GetBinError(1),2) ; } theHistCounter++; } }//end loop on samples //Fix the legend for (int iHisto = theHistCounter-1; iHisto >= 0; iHisto--) { leg -> AddEntry(hist[iHisto], theLegends[iHisto], "f"); } //get the maximum to properly set the frame float theMax = hdata -> GetBinContent(hdata -> GetMaximumBin()) + hdata -> GetBinError(hdata -> GetMaximumBin()); TH1* theMCSum = (TH1*) hs->GetStack()->Last(); cout << "total MC " << theMCSum -> GetBinContent(1) << " +/- " << theMCSum -> GetBinError(1) << endl; float theMaxMC = theMCSum->GetBinContent(theMCSum->GetMaximumBin()) + theMCSum->GetBinError(theMCSum->GetMaximumBin()); if (theMaxMC > theMax) theMax = theMaxMC; if (isBlind) cout << "total DATA " << hdata -> GetBinContent(1) << " +/- " << hdata -> GetBinError(1) << endl; //compute the scale factor float nData = hdata -> GetBinContent(1); float nDataErr = hdata -> GetBinError(1); newScaleFactor = (nData - nBkg)/(nSig/defScaleFactor); float newScaleFactorErr = sqrt( (pow(nDataErr,2) + nBkgErrSq)/(nData - nBkg)/(nData - nBkg) + nSigErrSq/nSig/nSig ) * newScaleFactor; cout << "\n The scale factor is " << newScaleFactor << " +/- " << newScaleFactorErr << endl; //cleanup the memory allocation delete theMCSum; delete hs; delete leg; delete hdata; infile -> Close(); delete infile; return; }
int main(int argc, char **argv){ vector <string> inputs; for (int i=1;i<argc;++i){ inputs.push_back(string(argv[i])); } if (inputs.size() == 0 ){ // no argumnets display helpful message cout<<"Usage: ./LendaAnalysis runNumber [options:value]"<<endl; return 0; } InputManager theInputManager; if ( ! theInputManager.loadInputs2(inputs) ){ return 0; } BuildBins(); //////////////////////////////////////////////////////////////////////////////////// //load settings Int_t runNum=theInputManager.runNum; Int_t numFiles=theInputManager.numFiles; Long64_t maxentry=theInputManager.maxEntry; //prepare files //////////////////////////////////////////////////////////////////////////////////// TFile *outFile=0; FileManager * fileMan = new FileManager(); fileMan->fileNotes = theInputManager.notes; ///The input trees are put into a TChain TChain * inT; if (theInputManager.specificFileName !=""){ inT= new TChain("flt"); for (int i=theInputManager.StartFile;i<theInputManager.StartFile+numFiles;i++){ TString s =fileMan->LoadFile(runNum,i,theInputManager.specificFileName); inT->Add(s); cout<<"Adding file "<<s<<endl; } } Long64_t nentry=(Long64_t) (inT->GetEntries()); cout <<"The number of entires is : "<< nentry << endl ; // Openning output Tree and output file stringstream temp; if ( theInputManager.StartFile !=0 ) temp<<"~/analysis/run"<<runNum<<"/Run"<<runNum<<"LA"<<theInputManager.StartFile<<".root"; else temp<<"~/analysis/run"<<runNum<<"/Run"<<runNum<<"LA0"<<".root"; outFile = new TFile(temp.str().c_str(),"recreate"); ////////////////////////////////////////////// ////////////////////////////////////////////// ////////////////////////////////////////////// ////////////////////////////////////////////// //Declare A Bunch Of histograms ////////////////////////////////////////////// ////////////////////////////////////////////// ////////////////////////////////////////////// ////////////////////////////////////////////// Int_t NumOfChannelsInModule=16; vector <TH1F*> EnergiesRaw(NumOfChannelsInModule); vector <TH1F*> EnergiesNoOFs(NumOfChannelsInModule); vector <TH1F*> EnergiesCorrected(NumOfChannelsInModule); vector< vector <TH1F*> > ReferenceEnergiesScaled(100); vector < vector <TH1F*> > EnergiesRawForN; //outer vector for various Multiplicities vector < vector <TH1F*> > EnergiesNoOFsForN; //outer vector for various Multiplicities vector < vector <TH1F*> > EnergiesCorrectedForN; //Defualt Binning For Energy Histograms Double_t ERawBinning[3]; ERawBinning[0]=1000; ERawBinning[1]=0; ERawBinning[2]=40000; //Raw Channels Histogram TH1F * ChannelsRaw = new TH1F("ChannelsRaw","ChannelsRaw",16,0,15); //Channels Histogram for different multiplicities vector <TH1F*> ChannelsForN; //Energy Cut settings for Channel histograms Double_t NumOfChannelECuts = 20; Double_t MaxEnergy = 7000; vector <TH1F *> ChannelsECut(NumOfChannelECuts); TH1F * Multiplicity = new TH1F("Multiplicity","Multiplicity",16,0,15); stringstream nameStream; for (int i=0;i<NumOfChannelsInModule;i++){ nameStream.str(""); nameStream<<"ERaw"<<i; EnergiesRaw[i]= new TH1F(nameStream.str().c_str(),nameStream.str().c_str(), ERawBinning[0],ERawBinning[1],ERawBinning[2]); nameStream.str(""); nameStream<<"ENoOverFlows"<<i; EnergiesNoOFs[i]= new TH1F(nameStream.str().c_str(),nameStream.str().c_str(), // use same binning as raw histos ERawBinning[0],ERawBinning[1],ERawBinning[2]); nameStream.str(""); nameStream<<"ECor"<<i; EnergiesCorrected[i]= new TH1F(nameStream.str().c_str(),nameStream.str().c_str(), // use same binning as raw histos ERawBinning[0],ERawBinning[1],ERawBinning[2]); } for (int i=0;i<ReferenceEnergiesScaled.size();i++){ ReferenceEnergiesScaled[i].resize(100); for (int j=0;j<ReferenceEnergiesScaled[i].size();j++){ nameStream.str(""); nameStream<<"RefScaledE"<<i<<"_"<<j; ReferenceEnergiesScaled[i][j] = new TH1F(nameStream.str().c_str(),nameStream.str().c_str(), 500,ERawBinning[1],ERawBinning[2]); } } Int_t MaxMultiplicity=6; EnergiesRawForN.resize(MaxMultiplicity); EnergiesNoOFsForN.resize(MaxMultiplicity); EnergiesCorrectedForN.resize(MaxMultiplicity); ChannelsForN.resize(MaxMultiplicity); TH2F* test = new TH2F("test","",1000,0,20000,1000,0,20000); TH2F* PulseShapeTrig = new TH2F("PulseShapeTrig","",1000,0,20000,1000,0,5); TH2F* LongVShortTrig = new TH2F("LongVShortTrig","",1000,0,20000,1000,0,20000); vector <TH2F*> LongVShortTrigForN(MaxMultiplicity); vector <TH2F*> PulseShapeTrigForN(MaxMultiplicity); TH2F* PulseShapeRef = new TH2F("PulseShapeRef","",1000,0,20000,1000,0,5); TH2F* LongVShortRef = new TH2F("LongVShortRef","",1000,0,20000,1000,0,20000); vector <TH2F*> LongVShortRefForN(MaxMultiplicity); vector <TH2F*> PulseShapeRefForN(MaxMultiplicity); //Declare things histograms for particular multiplicities for (int j=0;j<MaxMultiplicity;j++){ for (int i=0;i<NumOfChannelsInModule;i++){ nameStream.str(""); nameStream<<"ERaw"<<i<<"N"<<j+1; EnergiesRawForN[j].push_back( new TH1F(nameStream.str().c_str(),nameStream.str().c_str(), ERawBinning[0],ERawBinning[1],ERawBinning[2])); nameStream.str(""); nameStream<<"ENoOverFlows"<<i<<"N"<<j+1; EnergiesNoOFsForN[j].push_back( new TH1F(nameStream.str().c_str(),nameStream.str().c_str(), // use same binning as raw histos ERawBinning[0],ERawBinning[1],ERawBinning[2])); nameStream.str(""); nameStream<<"ECor"<<i<<"N"<<j+1; EnergiesCorrectedForN[j].push_back( new TH1F(nameStream.str().c_str(),nameStream.str().c_str(), // use same binning as raw histos ERawBinning[0],ERawBinning[1],ERawBinning[2])); } nameStream.str(""); nameStream<<"ChannelsN"<<j+1; ChannelsForN[j] = new TH1F(nameStream.str().c_str(),nameStream.str().c_str(),16,0,15); //Trigger Scint for N nameStream.str(""); nameStream<<"LongVShortTrigN"<<j+1; LongVShortTrigForN[j] = new TH2F(nameStream.str().c_str(),"",1000,0,20000,1000,0,20000); nameStream.str(""); nameStream<<"PulseShapeTrigN"<<j+1; PulseShapeTrigForN[j] = new TH2F(nameStream.str().c_str(),"",1000,0,20000,1000,0,5); //Reference Scint for N nameStream.str(""); nameStream<<"LongVShortRefN"<<j+1; LongVShortRefForN[j] = new TH2F(nameStream.str().c_str(),"",1000,0,20000,1000,0,20000); nameStream.str(""); nameStream<<"PulseShapeRefN"<<j+1; PulseShapeRefForN[j] = new TH2F(nameStream.str().c_str(),"",1000,0,20000,1000,0,5); } for (int i=0;i<NumOfChannelECuts;i++){ nameStream.str(""); nameStream<<"ChannelsECut_"<<floor((i/NumOfChannelECuts)*MaxEnergy); ChannelsECut[i] = new TH1F(nameStream.str().c_str(),nameStream.str().c_str(),16,0,15); } int nBinsForTOF=16000; int nBinsForLLEnergy=200; int nBinsForEnergy=1000; ///Time of Flight spectra for lenda bar in coincidence with trigger TH1F * TOF = new TH1F("TOF","",nBinsForTOF,-150,150);// Time of flight in clock tics raw TH1F * TOFPS = new TH1F("TOFPS","",nBinsForTOF,-150,150);// Time of flight in clock tics with PS TH1F * ShiftTOF = new TH1F("ShiftTOF","",nBinsForTOF,-150,150);// Time of flight in clock tics After GammaPeak Shift TH1F * TOFWithPS = new TH1F("TOFWithPS","",nBinsForTOF,-150,150);// Time of Flight with only Gammas on trig TH1F * TOFEnergy = new TH1F("TOFEnergy","",nBinsForTOF,0,150); // the Energy from TOF Raw TH1F * TOFEnergyNeutrons = new TH1F("TOFEnergyNeutrons","",nBinsForEnergy,0,20); // TOF energy with gammas cut and PS TH1F* TOFEnergyRandomBkg = new TH1F("TOFEnergyRandomBkg","",nBinsForEnergy,0,20);// TOF energy for negative time Of Flights TH1F* TOFEnergyRBkgSubtracted = new TH1F("TOFEnergyRBkgSubtracted","",nBinsForEnergy,0,20);// TOFEnergyNeutrons-TOFEnergyRandomBkg TH1F* TOFEnergyCFBins = new TH1F("TOFEnergyCFBins","",NumOfCFBins,CFBins); TH1F* TOFEnergyBkgCFBins = new TH1F("TOFEnergyBkgCFBins","",NumOfCFBins,CFBins); TH1F* TOFEnergySubCFBins = new TH1F("TOFEnergySubCFBins","",NumOfCFBins,CFBins); TH2F* EvsTOFEnergy = new TH2F("EvsTOFEnergy","",nBinsForEnergy,0,20,1000,0,20000); TH2F* EvsTOFEnergyBkg = new TH2F("EvsTOFEnergyBkg","",nBinsForEnergy,0,20,1000,0,20000); ////Time of Flight spectra for reference scintillator in coincidence with trigger TH1F * TOFL_L = new TH1F("TOFL_L","",nBinsForTOF,-150,150);// Time of flight in clock tics raw TH1F * TOFPSL_L = new TH1F("TOFPSL_L","",nBinsForTOF,-150,150);// Time of flight in clock tics with PS TH1F * ShiftTOFL_L = new TH1F("ShiftTOFL_L","",nBinsForTOF,-150,150);// Time of flight in clock tics After GammaPeak Shift TH1F * TOFWithPSL_L = new TH1F("TOFWithPSL_L","",nBinsForTOF,-150,150);// Time of Flight with only Gammas on trig TH1F * TOFWith2PSL_L = new TH1F("TOFWith2PSL_L","",nBinsForTOF,-150,150);// Time of Flight with only Gammas on trig TH1F * TOFEnergyL_L = new TH1F("TOFEnergyL_L","",nBinsForTOF,0,150); // the Energy from TOF Raw TH1F * TOFEnergyNeutronsL_L = new TH1F("TOFEnergyNeutronsL_L","",nBinsForLLEnergy,0,20); // TOF energy with gammas cut and PS TH1F * TOFEnergyRandomBkgL_L = new TH1F("TOFEnergyRandomBkgL_L","",nBinsForLLEnergy,0,20);// TOF energy for negative time Of Flights TH1F * TOFEnergyNeutrons1PSL_L = new TH1F("TOFEnergyNeutrons1PSL_L","",nBinsForLLEnergy,0,20); // TOF energy with gammas cut and PS TH1F * TOFEnergyRandomBkg1PSL_L = new TH1F("TOFEnergyRandomBkg1PSL_L","",nBinsForLLEnergy,0,20);// TOF energy for negative time Of Flights TH1F * TOFEnergyRBkgSubtracted1PSL_L = new TH1F("TOFEnergyRBkgSubtracted1PSL_L","",nBinsForLLEnergy,0,20);// TH1F* TOFEnergyCFBinsL_L = new TH1F("TOFEnergyCFBinsL_L","",NumOfCFBins,CFBins); TH1F* TOFEnergyBkgCFBinsL_L = new TH1F("TOFEnergyBkgCFBinsL_L","",NumOfCFBins,CFBins); TH1F* TOFEnergySubCFBinsL_L = new TH1F("TOFEnergySubCFBinsL_L","",NumOfCFBins,CFBins); TH2F* EvsTOFEnergyL_L = new TH2F("EvsTOFEnergyL_L","",nBinsForLLEnergy,0,20,1000,0,20000); TH2F* EvsTOFEnergyBkgL_L = new TH2F("EvsTOFEnergyBkgL_L","",nBinsForLLEnergy,0,20,1000,0,20000); double RefScintThresh=313.619; vector<double> threshVals(2); threshVals[0]=43.9740; threshVals[1]=153.647;//{ Americum 26.3, americium 59.5} vector <TH1F*> LendaThreshs(threshVals.size()); vector <TH1F*> LendaThreshsBkg(threshVals.size()); vector <TH1F*> LendaThreshsResult(threshVals.size()); for (int i=0;i<threshVals.size();i++){ nameStream.str(""); nameStream<<"LendaThresh_"<<TMath::Floor(threshVals[i]); LendaThreshs[i] = new TH1F(nameStream.str().c_str(),"",NumOfCFBins,CFBins); nameStream.str(""); nameStream<<"LendaThreshBkg_"<<TMath::Floor(threshVals[i]); LendaThreshsBkg[i] = new TH1F(nameStream.str().c_str(),"",NumOfCFBins,CFBins); nameStream.str(""); nameStream<<"LendaThreshSub_"<<TMath::Floor(threshVals[i]); LendaThreshsResult[i] = new TH1F(nameStream.str().c_str(),"",NumOfCFBins,CFBins); } ////////////////////////////////////////////// ////////////////////////////////////////////// ////////////////////////////////////////////// ////////////////////////////////////////////// //Main Analysis Loop ////////////////////////////////////////////// ////////////////////////////////////////////// ////////////////////////////////////////////// ////////////////////////////////////////////// LendaEvent * theEvent = new LendaEvent(); inT->SetBranchAddress("Event",&theEvent); for (Long64_t jentry=0;jentry<nentry;jentry++){ // LOOP OVER ALL EVENTS inT->GetEntry(jentry);//Get the Event From The TREE for (int i=0;i<theEvent->N;i++){ //Loop Over all Channel Firings in the Event //Fill Raw energy Histogram EnergiesRaw[theEvent->channels[i]]->Fill(theEvent->energies[i]); ///Fill Raw Energy Histograms for particlar Multiplicities EnergiesRawForN[theEvent->N-1][theEvent->channels[i]]->Fill(theEvent->energies[i]); if (theEvent->OverFlows[i] == false){ //Fill Energies no OFs for particular Multiplicities EnergiesNoOFsForN[theEvent->N-1][theEvent->channels[i]]->Fill(theEvent->energies[i]); //Fill Raw No overflow histogram EnergiesNoOFs[theEvent->channels[i]]->Fill(theEvent->energies[i]); //Fill Corrected Energies EnergiesCorrected[theEvent->channels[i]]->Fill(theEvent->energiesCor[i]); EnergiesCorrectedForN[theEvent->N-1][theEvent->channels[i]]->Fill(theEvent->energiesCor[i]); if (theEvent->channels[i] == 9 && theEvent->longGates[i]>0){ //Pulse Shape discrimination for the trigger PulseShapeTrig->Fill(theEvent->longGates[i],theEvent->longGates[i]/theEvent->shortGates[i]); LongVShortTrig->Fill(theEvent->shortGates[i],theEvent->longGates[i]); LongVShortTrigForN[theEvent->N-1]->Fill(theEvent->shortGates[i],theEvent->longGates[i]); PulseShapeTrigForN[theEvent->N-1]->Fill(theEvent->longGates[i],theEvent->longGates[i]/theEvent->shortGates[i]); } if (theEvent->channels[i] == 8 && theEvent->longGates[i]>0){ //Pulse Shape discrimination for the reference PulseShapeRef->Fill(theEvent->longGates[i],theEvent->longGates[i]/theEvent->shortGates[i]); LongVShortRef->Fill(theEvent->shortGates[i],theEvent->longGates[i]); LongVShortRefForN[theEvent->N-1]->Fill(theEvent->shortGates[i],theEvent->longGates[i]); PulseShapeRefForN[theEvent->N-1]->Fill(theEvent->longGates[i],theEvent->longGates[i]/theEvent->shortGates[i]); } if (theEvent->N == 2 && theEvent->channels[0]==8 && theEvent->channels[1]==9&&theEvent->channels[i]==8){ if (TMath::Abs(theEvent->times[0]-theEvent->times[1]) < 35 ){ test->Fill(theEvent->shortGates[i],theEvent->longGates[i]); } } } ///Fill Raw Channels Histogram ChannelsRaw->Fill(theEvent->channels[i]); //Fill Channels Histogram with energy cut and remove OFs for (int a=0;a<ChannelsECut.size();a++){ if (theEvent->energies[i]>(double(a)/ChannelsECut.size())*MaxEnergy && theEvent->OverFlows[i]==false){ ChannelsECut[a]->Fill(theEvent->channels[i]); } } //Fill channels for different multiplicities ChannelsForN[theEvent->N-1]->Fill(theEvent->channels[i]); }//End Loop over Channels In Event //Fill total event histograms like TOF //For the Lenda bar in coincidence with the trigger if (theEvent->N==3 && theEvent->channels[0]==0 && theEvent->channels[1]==1 &&theEvent->channels[2]==9){ TOF->Fill(theEvent->TOF); ShiftTOF->Fill(theEvent->ShiftTOF); TOFEnergy->Fill(theEvent->TOFEnergy); if (theEvent->longGates[2]>1200 && theEvent->longGates[2]/theEvent->shortGates[2]<1.14){ TOFWithPS->Fill(theEvent->ShiftTOF); TOFPS->Fill(theEvent->TOF); // just ps no shift if (theEvent->ShiftTOF > 2.5 && theEvent->ShiftTOF<100){ TOFEnergyNeutrons->Fill(theEvent->TOFEnergy); TOFEnergyCFBins->Fill(theEvent->TOFEnergy); EvsTOFEnergy->Fill(theEvent->TOFEnergy,sqrt(theEvent->energies[0]*theEvent->energies[1])); //loop over the different threshold options for lenda spectra for (int a=0;a<LendaThreshs.size();a++){ if (TMath::Sqrt(theEvent->energies[0]*theEvent->energies[1])>threshVals[a]){ LendaThreshs[a]->Fill(theEvent->TOFEnergy); } } } if (theEvent->ShiftTOF < -2.5 && theEvent->ShiftTOF>-100){ TOFEnergyRandomBkg->Fill(theEvent->TOFEnergy); TOFEnergyBkgCFBins->Fill(theEvent->TOFEnergy); EvsTOFEnergyBkg->Fill(theEvent->TOFEnergy,sqrt(theEvent->energies[0]*theEvent->energies[1])); //Loop over the different threshold option for lenda background spectra for (int a=0;a<LendaThreshsBkg.size();a++){ if (TMath::Sqrt(theEvent->energies[0]*theEvent->energies[1])>threshVals[a]){ LendaThreshsBkg[a]->Fill(theEvent->TOFEnergy); } } } } } //for the reference in coincidence with the trigger if (theEvent->N==2 && theEvent->channels[0]==8 && theEvent->channels[1]==9){ TOFL_L->Fill(theEvent->TOF); ShiftTOFL_L->Fill(theEvent->ShiftTOF); TOFEnergyL_L->Fill(theEvent->TOFEnergy); if (theEvent->longGates[1]>1200 && theEvent->longGates[1]/theEvent->shortGates[1]<1.14){ TOFWithPSL_L->Fill(theEvent->ShiftTOF); TOFPSL_L->Fill(theEvent->TOF); if (theEvent->longGates[0]>2000 && theEvent->longGates[0]/theEvent->shortGates[0]>1.06){ TOFWith2PSL_L->Fill(theEvent->ShiftTOF); if (theEvent->ShiftTOF > 2 && theEvent->ShiftTOF<35){ TOFEnergyNeutronsL_L->Fill(theEvent->TOFEnergy); } if (theEvent->ShiftTOF < -2 && theEvent->ShiftTOF>-35){ TOFEnergyRandomBkgL_L->Fill(theEvent->TOFEnergy); } } //end if over second pusle shape discrimination //Fill the histograms that have the specifed threhold cut in them if (theEvent->ShiftTOF > 2 && theEvent->ShiftTOF<35){ if ( theEvent->energies[0]>RefScintThresh){ TOFEnergyNeutrons1PSL_L->Fill(theEvent->TOFEnergy); TOFEnergyCFBinsL_L->Fill(theEvent->TOFEnergy); EvsTOFEnergyL_L->Fill(theEvent->TOFEnergy,theEvent->energies[0]); } } if (theEvent->ShiftTOF < -2 && theEvent->ShiftTOF>-35){ if ( theEvent->energies[0]>RefScintThresh){ TOFEnergyRandomBkg1PSL_L->Fill(theEvent->TOFEnergy); TOFEnergyBkgCFBinsL_L->Fill(theEvent->TOFEnergy); EvsTOFEnergyBkgL_L->Fill(theEvent->TOFEnergy,theEvent->energies[0]); } } } } Multiplicity->Fill(theEvent->N); if ( jentry % 100000 == 0){ cout<<"ON "<<jentry<<endl; } }//End Main Loop over Everything ///Do analysis on whole historgrams ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// for (int i=1;i<=TOFEnergyNeutrons->GetXaxis()->GetNbins();i++){ Float_t N = TOFEnergyNeutrons->GetBinContent(i); Float_t NRandom = TOFEnergyRandomBkg->GetBinContent(i); TOFEnergyRBkgSubtracted->SetBinContent(i,N-NRandom); TOFEnergyRBkgSubtracted->SetBinError(i,TMath::Sqrt(N+NRandom)); Float_t NL_L =TOFEnergyNeutrons1PSL_L->GetBinContent(i); Float_t NRandomL_L=TOFEnergyRandomBkg1PSL_L->GetBinContent(i); TOFEnergyRBkgSubtracted1PSL_L->SetBinContent(i,NL_L-NRandomL_L); TOFEnergyRBkgSubtracted1PSL_L->SetBinError(i,TMath::Sqrt(NL_L+NRandomL_L)); } //Spectra that have the CF BINNING for (int i=1;i<=TOFEnergySubCFBins->GetXaxis()->GetNbins();i++){ Float_t N =TOFEnergyCFBins->GetBinContent(i); Float_t NRandom=TOFEnergyBkgCFBins->GetBinContent(i); TOFEnergySubCFBins->SetBinContent(i,N-NRandom); TOFEnergySubCFBins->SetBinError(i,TMath::Sqrt(N+NRandom)); Float_t NL_L = TOFEnergyCFBinsL_L->GetBinContent(i); Float_t NRandomL_L=TOFEnergyBkgCFBinsL_L->GetBinContent(i); TOFEnergySubCFBinsL_L->SetBinContent(i,NL_L-NRandomL_L); TOFEnergySubCFBinsL_L->SetBinError(i,TMath::Sqrt(NL_L+NRandomL_L)); for (int a=0;a<LendaThreshs.size();a++){ Float_t thisN=LendaThreshs[a]->GetBinContent(i); Float_t thisNRandom=LendaThreshsBkg[a]->GetBinContent(i); LendaThreshsResult[a]->SetBinContent(i,thisN-thisNRandom); LendaThreshsResult[a]->SetBinError(i,sqrt(thisN+thisNRandom)); } } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Write all the histograms to file //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// for (int i=0;i<EnergiesNoOFsForN.size();i++){ for (int j=0;j<EnergiesNoOFsForN[i].size();j++){ EnergiesNoOFsForN[i][j]->Write(); EnergiesRawForN[i][j]->Write(); EnergiesCorrectedForN[i][j]->Write(); } } for (int i=0;i<ChannelsForN.size();i++){ ChannelsForN[i]->Write(); } for (int i=0;i<EnergiesRaw.size();i++){ EnergiesRaw[i]->Write(); EnergiesNoOFs[i]->Write(); EnergiesCorrected[i]->Write(); } for (int i=0;i<ChannelsECut.size();i++){ ChannelsECut[i]->Write(); } for (int i=0;i<LongVShortTrigForN.size();i++){ LongVShortTrigForN[i]->Write(); PulseShapeTrigForN[i]->Write(); LongVShortRefForN[i]->Write(); PulseShapeRefForN[i]->Write(); } ChannelsRaw->Write(); Multiplicity->Write(); test->Write(); PulseShapeTrig->Write(); LongVShortTrig->Write(); PulseShapeRef->Write(); LongVShortRef->Write(); TOFEnergy->Write(); TOFEnergyNeutrons->Write(); ShiftTOF->Write(); TOF->Write(); TOFWithPS->Write(); TOFEnergyRandomBkg->Write(); TOFEnergyRBkgSubtracted->Write(); TOFEnergyCFBins->Write(); TOFEnergyBkgCFBins->Write(); TOFEnergySubCFBins->Write(); EvsTOFEnergy->Write(); TOFPSL_L->Write(); TOFPS->Write(); EvsTOFEnergyBkg->Write(); TOFEnergyL_L->Write(); TOFEnergyNeutronsL_L->Write(); ShiftTOFL_L->Write(); TOFL_L->Write(); TOFWithPSL_L->Write(); TOFWith2PSL_L->Write(); TOFEnergyRandomBkgL_L->Write(); TOFEnergyRBkgSubtracted1PSL_L->Write(); TOFEnergyCFBinsL_L->Write(); TOFEnergyBkgCFBinsL_L->Write(); TOFEnergySubCFBinsL_L->Write(); TOFEnergyNeutrons1PSL_L->Write(); TOFEnergyRandomBkg1PSL_L->Write(); EvsTOFEnergyL_L->Write(); EvsTOFEnergyBkgL_L->Write(); for (int i=0;i<LendaThreshs.size();i++){ LendaThreshs[i]->Write(); LendaThreshsBkg[i]->Write(); LendaThreshsResult[i]->Write(); } /* for (int i=0;i<ReferenceEnergiesScaled.size();i++){ for (int j=0;j<ReferenceEnergiesScaled[i].size();j++){ ReferenceEnergiesScaled[i][j]->Scale(20); // ReferenceEnergiesScaled[i][j]->Write(); } } for (int i=0;i<ThreshHoldVaryL_L.size();i++){ // ThreshHoldVaryL_L[i]->Write(); // ThreshHoldVaryBkgL_L[i]->Write(); // ThreshHoldVaryResultL_L[i]->Write(); }*/ outFile->Close(); cout<<"\n\n*****Finished******"<<endl; return 0; }
/// /// Make a plot out of a 1D histogram holding a 1-CL curve. /// The strategy is to always convert the 1-CL histogram (hCL) into /// a TGraph. This way we can add known points (solutions, points /// at end of scan range) and also have a filled area without line /// smoothing. This is not possible with histograms due to a Root bug. /// /// The function draws the TGraphs, and returns a pointer to the /// TGraph object that can be used in the TLegend. /// /// Markers are plotted if the method name of the scanner is "Plugin" or "BergerBoos" or "DatasetsPlugin". /// One can plot a line instead of points even for the Plugin method by /// using setPluginMarkers(). /// /// For the angle variables, a new axis is painted that is in Deg. /// /// \param s The scanner to plot. /// \param first /// \param last /// \param filled /// TGraph* OneMinusClPlot::scan1dPlot(MethodAbsScan* s, bool first, bool last, bool filled, int CLsType) { if ( arg->debug ){ cout << "OneMinusClPlot::scan1dPlot() : plotting "; cout << s->getName() << " (" << s->getMethodName() << ")" << endl; } if ( m_mainCanvas==0 ){ m_mainCanvas = newNoWarnTCanvas(name+getUniqueRootName(), title, 800, 600); } m_mainCanvas->cd(); bool plotPoints = ( s->getMethodName()=="Plugin" || s->getMethodName()=="BergerBoos" || s->getMethodName()=="DatasetsPlugin" ) && plotPluginMarkers; TH1F *hCL = (TH1F*)s->getHCL()->Clone(getUniqueRootName()); if (CLsType==1) hCL = (TH1F*)s->getHCLs()->Clone(getUniqueRootName()); else if (CLsType==2) hCL = (TH1F*)s->getHCLsFreq()->Clone(getUniqueRootName()); // fix inf and nan entries for ( int i=1; i<=s->getHCL()->GetNbinsX(); i++ ){ if ( s->getHCL()->GetBinContent(i)!=s->getHCL()->GetBinContent(i) || std::isinf(s->getHCL()->GetBinContent(i)) ) s->getHCL()->SetBinContent(i, 0.0); } // remove errors the hard way, else root ALWAYS plots them if ( !plotPoints ) hCL = histHardCopy(hCL, true, true); // disable any statistics box hCL->SetStats(0); // Convert the histogram into a TGraph so we can add the solution. // Also, the lf2 drawing option is broken in latest root versions. TGraph *g; if ( plotPoints ) g = new TGraphErrors(hCL->GetNbinsX()); else g = new TGraph(hCL->GetNbinsX()); g->SetName(getUniqueRootName()); for ( int i=0; i<hCL->GetNbinsX(); i++ ){ g->SetPoint(i, hCL->GetBinCenter(i+1), hCL->GetBinContent(i+1)); if ( plotPoints ) ((TGraphErrors*)g)->SetPointError(i, 0.0, hCL->GetBinError(i+1)); } // add solution if ( ! s->getSolutions().empty() ){ TGraphTools t; TGraph *gNew = t.addPointToGraphAtFirstMatchingX(g, s->getScanVar1Solution(0), 1.0); delete g; g = gNew; } // // set last point to the same p-value as first point by hand // // some angle plots sometimes don't manage to do it by themselves... // if ( arg->isQuickhack(XX) ) // { // Double_t pointx0, pointy0, err0; // Double_t pointx1, pointy1, err1; // g->GetPoint(0, pointx0, pointy0); // g->GetPoint(g->GetN()-1, pointx1, pointy1); // g->SetPoint(g->GetN()-1, pointx1, pointy0); // if ( plotPoints ) err0 = ((TGraphErrors*)g)->GetErrorY(0); // if ( plotPoints ) ((TGraphErrors*)g)->SetPointError(g->GetN()-1, 0.0, err0); // } // add end points of scan range if ( !plotPoints ) { Double_t pointx0, pointy0; TGraph *gNew = new TGraph(g->GetN()+4); gNew->SetName(getUniqueRootName()); for ( int i=0; i<g->GetN(); i++) { g->GetPoint(i, pointx0, pointy0); gNew->SetPoint(i+2, pointx0, pointy0); } // add origin gNew->SetPoint(0, hCL->GetXaxis()->GetXmin(), 0); // add a point at first y height but at x=origin. g->GetPoint(0, pointx0, pointy0); gNew->SetPoint(1, hCL->GetXaxis()->GetXmin(), pointy0); // add a point at last y height but at x=xmax. g->GetPoint(g->GetN()-1, pointx0, pointy0); gNew->SetPoint(gNew->GetN()-2, hCL->GetXaxis()->GetXmax(), pointy0); // add a point at xmax, 0 gNew->SetPoint(gNew->GetN()-1, hCL->GetXaxis()->GetXmax(), 0); g = gNew; } int color = s->getLineColor(); if(CLsType>0 && s->getMethodName().Contains("Plugin") && !arg->plotpluginonly) { if (CLsType==1) color = kBlue-7; else if (CLsType==2) color = kBlue+2; } else if(CLsType>0) { if (CLsType==1) color = s->getLineColor() - 5; if (CLsType==2) color = s->getLineColor() - 4; } g->SetLineColor(color); if ( filled ){ g->SetLineWidth(2); double alpha = arg->isQuickhack(12) ? 0.4 : 1.; if ( arg->isQuickhack(24) ) alpha = 0.; g->SetFillColorAlpha(color,alpha); g->SetLineStyle(1); g->SetFillStyle( s->getFillStyle() ); } else{ g->SetLineWidth(2); g->SetLineStyle(s->getLineStyle()); if ( last && arg->isQuickhack(25) ) g->SetLineWidth(3); } if ( plotPoints ){ g->SetLineWidth(1); g->SetMarkerColor(color); g->SetMarkerStyle(8); g->SetMarkerSize(0.6); if(CLsType==1) { g->SetMarkerStyle(33); g->SetMarkerSize(1); } if(CLsType==2) { g->SetMarkerStyle(21); } } // build a histogram which holds the axes float min = arg->scanrangeMin == arg->scanrangeMax ? hCL->GetXaxis()->GetXmin() : arg->scanrangeMin; float max = arg->scanrangeMin == arg->scanrangeMax ? hCL->GetXaxis()->GetXmax() : arg->scanrangeMax; TH1F *haxes = new TH1F("haxes"+getUniqueRootName(), "", 100, min, max); haxes->SetStats(0); haxes->GetXaxis()->SetTitle(s->getScanVar1()->GetTitle()); haxes->GetYaxis()->SetTitle("1-CL"); haxes->GetXaxis()->SetLabelFont(font); haxes->GetYaxis()->SetLabelFont(font); haxes->GetXaxis()->SetTitleFont(font); haxes->GetYaxis()->SetTitleFont(font); haxes->GetXaxis()->SetTitleOffset(0.9); haxes->GetYaxis()->SetTitleOffset(0.85); haxes->GetXaxis()->SetLabelSize(labelsize); haxes->GetYaxis()->SetLabelSize(labelsize); haxes->GetXaxis()->SetTitleSize(titlesize); haxes->GetYaxis()->SetTitleSize(titlesize); int xndiv = arg->ndiv==-1 ? 407 : abs(arg->ndiv); bool optimizeNdiv = arg->ndiv<0 ? true : false; haxes->GetXaxis()->SetNdivisions(xndiv, optimizeNdiv); haxes->GetYaxis()->SetNdivisions(407, true); // plot y range float plotYMax; float plotYMin; if ( plotLegend && !arg->isQuickhack(22) ) { if ( arg->plotlog ) { plotYMin = 1.e-3; plotYMax = 10.; } else { plotYMin = 0.0 ; plotYMax = 1.3; } } else { if ( arg->plotlog ) { plotYMin = 1.e-3; plotYMax = 1.0; } else { plotYMin = 0.0 ; plotYMax = 1.0; } } // change if passed as option plotYMin = arg->plotymin > 0. ? arg->plotymin : plotYMin; plotYMax = arg->plotymax > 0. ? arg->plotymax : plotYMax; haxes->GetYaxis()->SetRangeUser( plotYMin, plotYMax ); haxes->Draw("axissame"); g->SetHistogram(haxes); TString drawOption = ""; if ( plotPoints ) drawOption += " pe"; else if ( filled ) drawOption += " F"; else drawOption += " L"; if ( first ) drawOption += " A"; g->Draw(drawOption); //if ( drawOption.Contains("F") ) ((TGraph*)g->Clone())->Draw("L"); gPad->Update(); float ymin = gPad->GetUymin(); float ymax = gPad->GetUymax(); float xmin = gPad->GetUxmin(); float xmax = gPad->GetUxmax(); // for the angles, draw a new axis in units of degrees if ( isAngle(s->getScanVar1()) ){ haxes->GetXaxis()->SetTitle(s->getScanVar1()->GetTitle() + TString(" [#circ]")); haxes->GetXaxis()->SetNdivisions(0); // disable old axis if ( last ){ // new top axis TString chopt = "-U"; // - = downward ticks, U = unlabeled, http://root.cern.ch/root/html534/TGaxis.html if ( !optimizeNdiv ) chopt += "N"; // n = no bin optimization TGaxis *axist = new TGaxis(xmin, 1, xmax, 1, RadToDeg(xmin), RadToDeg(xmax), xndiv, chopt); axist->SetName("axist"); axist->Draw(); // new bottom axis float axisbMin = RadToDeg(xmin); float axisbMax = RadToDeg(xmax); if ( arg->isQuickhack(3) ){ ///< see documentation of --qh option in OptParser.cpp axisbMin += 180.; axisbMax += 180.; } chopt = ""; // - = downward ticks, U = unlabeled, http://root.cern.ch/root/html534/TGaxis.html if ( !optimizeNdiv ) chopt += "N"; // n = no bin optimization TGaxis *axisb = new TGaxis(xmin, ymin, xmax, ymin, axisbMin, axisbMax, xndiv, chopt); axisb->SetName("axisb"); axisb->SetLabelFont(font); axisb->SetLabelSize(labelsize); axisb->Draw(); } } else { if ( last ){ // add top axis TString chopt = "-U"; // - = downward ticks, U = unlabeled, http://root.cern.ch/root/html534/TGaxis.html if ( !optimizeNdiv ) chopt += "N"; // n = no bin optimization TGaxis *axist = new TGaxis(xmin, 1.0, xmax, 1.0, xmin, xmax, xndiv, chopt); axist->SetName("axist"); axist->SetLineWidth(1); axist->Draw(); } } if ( last ) { // add right axis TGaxis *axisr = 0; if ( arg->plotlog ){ float f3min = 1e-3; float f3max = (plotLegend && !arg->isQuickhack(22)) ? 10. : 1.; TF1 *f3 = new TF1("f3","log10(x)",f3min,f3max); axisr = new TGaxis(xmax, f3min, xmax, f3max, "f3", 510, "G+"); } else{ axisr = new TGaxis(xmax, ymin, xmax, ymax, 0, (plotLegend && !arg->isQuickhack(22)) ? 1.3 : 1.0, 407, "+"); } axisr->SetLabelSize(0); axisr->SetLineWidth(1); axisr->SetName("axisr"); axisr->SetLabelColor(kWhite); axisr->SetTitleColor(kWhite); axisr->Draw(); // redraw right axis as well because the 1-CL graph can cover the old one haxes->Draw("axissame"); } return g; }
void GenerateInputFile_ge4b( double mgl=-1., double mlsp=-1., double target_susy_all0lep=-1. ) { TChain* dyTree = new TChain("treeZ") ; int nAdded = dyTree->Add("files15fb_8TeV_old1/DY.root") ; if ( nAdded <= 0 ) { printf("\n\n\n *** No treeZ in files15fb_8TeV_old1/DY.root\n\n\n") ; return ; } double t1bbbbWeight(0.) ; TChain chainT1bbbb("tree") ; char susycutstring[1000] ; sprintf( susycutstring, "&&mgluino==%.0f&&mlsp==%.0f", mgl, mlsp ) ; TString susycut( susycutstring ) ; if ( mgl>0. && mlsp>0. ) { nAdded = chainT1bbbb.Add("files5fb_MT/T1bbbb.root") ; if ( nAdded <= 0 ) { printf("\n\n\n *** No tree in files5fb_MT/T1bbbb.root\n\n\n") ; return ; } TFile f("referenceXSecs.root") ; TH1F* xsechist = (TH1F*) f.Get("gluino8TeV_NLONLL") ; if ( xsechist==0x0 ) { printf("\n\n *** can't find reference Xsec histogram in referenceXSecs.root.\n\n") ; return ; } int theBin = xsechist->FindBin( mgl ) ; if ( theBin <=0 || theBin > xsechist->GetNbinsX() ) { printf("\n\n *** can't find bin for mgl=%g. Returned %d\n\n", mgl, theBin ) ; return ; } double xsec = xsechist->GetBinContent( theBin ) ; printf("\n\n T1bbbb xsec for mgl=%g is %g\n\n", mgl, xsec ) ; t1bbbbWeight = 1.5*xsec ; //in pb. scan has 10k events, so nScan*1.5*xsec = events in 15fb-1 ////// t1bbbbWeight = 0.1*xsec ; //in pb. T1tttt scan has 50k events, so nScan*0.1*xsec = events in 5fb-1 printf("\n\n Susy ttree cut: %s\n\n", susycutstring ) ; } TChain chainQCD("tree") ; //--- these have high weight //chainQCD.Add("files15fb_8TeV/QCD-50to80.root"); //chainQCD.Add("files15fb_8TeV/QCD-80to120.root"); chainQCD.Add("files15fb_8TeV/QCD-120to170.root"); chainQCD.Add("files15fb_8TeV/QCD-170to300.root"); //--- below here, these have weight less than one. chainQCD.Add("files15fb_8TeV/QCD-300to470.root"); chainQCD.Add("files15fb_8TeV/QCD-470to600.root"); chainQCD.Add("files15fb_8TeV/QCD-600to800.root"); chainQCD.Add("files15fb_8TeV/QCD-800to1000.root"); chainQCD.Add("files15fb_8TeV/QCD-1000to1400.root"); chainQCD.Add("files15fb_8TeV/QCD-1400to1800.root"); chainQCD.Add("files15fb_8TeV/QCD-1800.root"); TChain chainTT("tree") ; chainTT.Add("files15fb_8TeV/TT.root") ; TChain chainZnn("tree") ; chainZnn.Add("files15fb_8TeV/Zinv-100to200.root") ; chainZnn.Add("files15fb_8TeV/Zinv-200to400.root") ; chainZnn.Add("files15fb_8TeV/Zinv-400.root") ; TChain chainWJets("tree") ; chainWJets.Add("files15fb_8TeV/WJets-250to300.root") ; chainWJets.Add("files15fb_8TeV/WJets-300to400.root") ; chainWJets.Add("files15fb_8TeV/WJets-400.root") ; chainWJets.Add("files15fb_8TeV/T-s.root") ; chainWJets.Add("files15fb_8TeV/T-t.root") ; chainWJets.Add("files15fb_8TeV/T-tW.root") ; chainWJets.Add("files15fb_8TeV/Tbar-s.root") ; chainWJets.Add("files15fb_8TeV/Tbar-t.root") ; chainWJets.Add("files15fb_8TeV/Tbar-tW.root") ; char qcdinputfile[9][1000] = { "files15fb_8TeV/QCD-120to170.root" ,"files15fb_8TeV/QCD-170to300.root" ,"files15fb_8TeV/QCD-300to470.root" ,"files15fb_8TeV/QCD-470to600.root" ,"files15fb_8TeV/QCD-600to800.root" ,"files15fb_8TeV/QCD-800to1000.root" ,"files15fb_8TeV/QCD-1000to1400.root" ,"files15fb_8TeV/QCD-1400to1800.root" ,"files15fb_8TeV/QCD-1800.root" } ; char qcdsamplename[9][100] = { "qcd_0120_to_0170" ,"qcd_0170_to_0300" ,"qcd_0300_to_0470" ,"qcd_0470_to_0600" ,"qcd_0600_to_0800" ,"qcd_0800_to_1000" ,"qcd_1000_to_1400" ,"qcd_1400_to_1800" ,"qcd_1800_to_9999" } ; gROOT->Reset(); const int nBinsBjets = 4 ; const int nJetsCut = 3 ; // #jets >= nJetsCut //be careful because this is hard coded now in SmallTree::Loop double minLeadJetPt = 70. ; double min3rdJetPt = 50. ; bool doPUreweighting = false; //-- met2-ht1-v1 //const int nBinsMET = 2 ; //const int nBinsHT = 1 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,250.,99999.}; //float Hbins[nBinsHT+1] = {400.,99999.}; //-- met2-ht2-v1 //const int nBinsMET = 2 ; //const int nBinsHT = 2 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,250.,99999.}; //float Hbins[nBinsHT+1] = {400.,600.,99999.}; ////-- met2-ht8-v1 //const int nBinsMET = 2 ; //const int nBinsHT = 8 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,250.,99999.}; //float Hbins[nBinsHT+1] = {400.,500.,600.,700.,800.,900.,1000.,1200.,99999.}; //-- met3-ht2-v1 //const int nBinsMET = 3 ; //const int nBinsHT = 2 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,250.,350.,99999.}; //float Hbins[nBinsHT+1] = {400.,800.,99999.}; ////-- met3-ht3-v1 //const int nBinsMET = 3 ; //const int nBinsHT = 3 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,250.,350.,99999.}; //float Hbins[nBinsHT+1] = {400.,600.,1000.,99999.}; ////-- met3-ht3-v5 // const int nBinsMET = 3 ; // const int nBinsHT = 3 ; // const int version = 5; // float Mbins[nBinsMET+1] = { 125, 200, 350, 99999. } ; // float Hbins[nBinsHT+1] = { 400, 600, 1000, 99999. } ; ////-- met3-ht3-v2 //const int nBinsMET = 3 ; //const int nBinsHT = 3 ; // const int version = 2; //float Mbins[nBinsMET+1] = {150.,250.,350.,99999.}; //float Hbins[nBinsHT+1] = {300.,500.,1000.,99999.}; ////-- met3-ht4-v1 //const int nBinsMET = 3 ; //const int nBinsHT = 4 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,250.,350.,99999.}; //float Hbins[nBinsHT+1] = {200, 300.,500.,1000.,99999.}; ////-- met3-ht5-v1 //const int nBinsMET = 3 ; //const int nBinsHT = 5 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,250.,350.,99999.}; //float Hbins[nBinsHT+1] = {400.,500.,600.,800.,1000.,99999.}; ////-- met4-ht3-v1 //const int nBinsMET = 4 ; //const int nBinsHT = 3 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,250.,350.,500.,99999.}; //float Hbins[nBinsHT+1] = {400.,600.,1000.,99999.}; ////-- met4-ht3-v2 //const int nBinsMET = 4 ; //const int nBinsHT = 3 ; // const int version = 2; //float Mbins[nBinsMET+1] = {125, 150.,250.,350.,99999.}; //float Hbins[nBinsHT+1] = {300.,500.,1000.,99999.}; //-- met5-ht4-v1 //const int nBinsMET = 5 ; //const int nBinsHT = 4 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,200.,250.,300.,350.,99999.}; //float Hbins[nBinsHT+1] = {400.,600.,800.,1000.,99999.}; ////-- met4-ht4-v1 // const int nBinsMET = 4 ; // const int nBinsHT = 4 ; // const int version = 1; // float Mbins[nBinsMET+1] = {150.,200.,250.,300.,99999.}; // float Hbins[nBinsHT+1] = {400.,500.,600.,800.,99999.}; //-- met4-ht4-v2 // const int nBinsMET = 4 ; // const int nBinsHT = 4 ; // const int version = 2; // float Mbins[nBinsMET+1] = {150.,250.,350.,450.,99999.}; // float Hbins[nBinsHT+1] = {400.,500.,600.,800.,99999.}; //-- met4-ht4-v3 // const int nBinsMET = 4 ; // const int nBinsHT = 4 ; // const int version = 3; // float Mbins[nBinsMET+1] = {150.,200.,250.,300.,99999.}; // float Hbins[nBinsHT+1] = {400.,600.,800.,1000.,99999.}; //-- met4-ht4-v4 // const int nBinsMET = 4 ; // const int nBinsHT = 4 ; // const int version = 4; // float Mbins[nBinsMET+1] = {150.,250.,350.,450.,99999.}; // float Hbins[nBinsHT+1] = {400.,600.,800.,1000.,99999.}; //-- met4-ht4-v5 // const int nBinsMET = 4 ; // const int nBinsHT = 4 ; // const int version = 5; // float Mbins[nBinsMET+1] = {150.,175.,200.,400.,99999.}; // float Hbins[nBinsHT+1] = {400.,450.,550.,850.,99999.}; //-- met4-ht4-v6 // const int nBinsMET = 4 ; // const int nBinsHT = 4 ; // const int version = 6; // float Mbins[nBinsMET+1] = {150.,200.,350.,450.,99999.}; // float Hbins[nBinsHT+1] = {400.,550.,800.,950.,99999.}; ////-- met4-ht4-v7 //const int nBinsMET = 4 ; //const int nBinsHT = 4 ; // const int version = 7; //float Mbins[nBinsMET+1] = {125, 150.,250.,350.,99999.}; //float Hbins[nBinsHT+1] = {200, 300.,500.,1000.,99999.}; //-- met4-ht4-v15 const int nBinsMET = 4 ; const int nBinsHT = 4 ; const int version = 15; float Mbins[nBinsMET+1] = {125.,150.,250.,350.,99999.}; float Hbins[nBinsHT+1] = {400.,500.,800.,1000.,99999.}; ////-- met4-ht5-v1 //const int nBinsMET = 4 ; //const int nBinsHT = 5 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,200.,300.,400.,99999.}; //float Hbins[nBinsHT+1] = {400.,600.,800.,1000.,1200.,99999.}; ////-- met5-ht5-v1 //const int nBinsMET = 5 ; //const int nBinsHT = 5 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,200.,250.,300.,350.,99999.}; //float Hbins[nBinsHT+1] = {400.,500.,600.,800.,1000.,99999.}; ////-- met5-ht3-v1 //const int nBinsMET = 5 ; //const int nBinsHT = 3 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,200.,250.,300.,350.,99999.}; //float Hbins[nBinsHT+1] = {400.,600.,1000.,99999.}; ////-- met5-ht3-v2 //const int nBinsMET = 5 ; //const int nBinsHT = 3 ; // const int version = 2; //float Mbins[nBinsMET+1] = {150.,175.,200.,350.,450.,99999.}; //float Hbins[nBinsHT+1] = {400.,550.,800.,99999.}; //-- met6-ht6-v1 //const int nBinsMET = 6 ; //const int nBinsHT = 6 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,200.,250.,300.,350.,400.,99999.}; //float Hbins[nBinsHT+1] = {400.,500.,600.,700.,800.,900.,99999.}; //-- met7-ht7-v1 //const int nBinsMET = 7 ; //const int nBinsHT = 7 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,200.,250.,300.,350.,400.,500.,99999.}; //float Hbins[nBinsHT+1] = {400.,500.,600.,700.,800.,900.,1000.,99999.}; ////-- met8-ht8-v1 //const int nBinsMET = 8 ; //const int nBinsHT = 8 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,200.,250.,300.,350.,400.,450.,600.,99999.}; //float Hbins[nBinsHT+1] = {400.,500.,600.,700.,800.,900.,1000.,1200.,99999.}; ////-- met8-ht2-v1 //const int nBinsMET = 8 ; //const int nBinsHT = 2 ; // const int version = 1; //float Mbins[nBinsMET+1] = {150.,200.,250.,300.,350.,400.,450.,600.,99999.}; //float Hbins[nBinsHT+1] = {400.,600.,99999.}; TString sMbins[nBinsMET]; TString sHbins[nBinsHT]; TString sBbins[nBinsBjets] = {"_1b","_2b","_3b","_4b"}; TString cMbins[nBinsMET]; TString cHbins[nBinsHT]; for (int i = 0 ; i < nBinsMET ; i++) { TString base = "_M"; stringstream sbin; sbin << i+1; base += sbin.str(); sMbins[i] = base; base = "&&MET>"; stringstream cbin; cbin << Mbins[i] << "&&MET<" << Mbins[i+1]; base += cbin.str(); cMbins[i] = base; } for (int j = 0 ; j < nBinsHT ; j++) { TString base = "_H"; stringstream sbin; sbin << j+1; base += sbin.str(); sHbins[j] = base; base = "&&HT>"; stringstream cbin; cbin << Hbins[j] << "&&HT<" << Hbins[j+1]; base += cbin.str(); cHbins[j] = base; } TString leadJetPtCutString ; { leadJetPtCutString = "(pt_1st_leadJet>" ; stringstream number ; number << minLeadJetPt ; stringstream number2 ; number2 << min3rdJetPt ; leadJetPtCutString += number.str() ; leadJetPtCutString += "&&pt_2nd_leadJet>" ; leadJetPtCutString += number.str() ; leadJetPtCutString += "&&pt_3rd_leadJet>" ; leadJetPtCutString += number2.str() ; leadJetPtCutString += ")" ; } //int dummyInt = 99; //float dummyFloat = 9.999; float dummyZero = 0.; float dummyOne = 1.0; float dummyPoint999 = 0.999 ; float dummyErr = 0.1; float sl_frac2b_val[nBinsMET][nBinsHT]; float sl_frac2b_err[nBinsMET][nBinsHT]; float sl_frac3b_val[nBinsMET][nBinsHT]; float sl_frac3b_err[nBinsMET][nBinsHT]; float sl_frac4b_val[nBinsMET][nBinsHT]; float sl_frac4b_err[nBinsMET][nBinsHT]; ofstream inFile; char outfile[10000] ; if ( mgl > 0. && mlsp > 0. ) { if ( target_susy_all0lep > 0. ) { sprintf( outfile, "InputWT1bbbb-nb4-mgl%.0f-mlsp%.0f-%.0fevts-met%d-ht%d-v%d.dat", mgl, mlsp, target_susy_all0lep, nBinsMET, nBinsHT, version ) ; } else { sprintf( outfile, "InputWT1bbbb-nb4-mgl%.0f-mlsp%.0f-met%d-ht%d-v%d.dat", mgl, mlsp, nBinsMET, nBinsHT, version ) ; } } else { sprintf( outfile, "Input-nb4-met%d-ht%d-v%d.dat", nBinsMET, nBinsHT, version ) ; } inFile.open( outfile ); // print out header line: inFile << "Using HT bins: " ; for (int j = 0 ; j <= nBinsHT ; j++ ) { inFile << Hbins[j] ; if ( j < nBinsHT ) inFile << "-" ; } inFile << "\t Using MET bins: " ; for (int i = 0 ; i <= nBinsMET ; i++ ) { inFile << Mbins[i] ; if ( i < nBinsMET ) inFile << "-" ; } inFile << endl ; int nSel(3) ; char selname[3][100] = { "0lep", "1lep", "ldp" } ; char selcuts[3][10000] = { "minDelPhiN>4&&nMu==0&&nEl==0&&", "minDelPhiN>4&&( (nMu==1&&nEl==0) || (nMu==0&&nEl==1) )&&", "minDelPhiN<4&&nMu==0&&nEl==0&&" } ; //--- Output histograms. TH1F* hmctruth_susy [3][4] ; TH1F* hmctruth_ttwj [3][4] ; TH1F* hmctruth_ttbar[3][4] ; TH1F* hmctruth_wjets[3][4] ; TH1F* hmctruth_qcd [3][4] ; TH1F* hmctruth_znn [3][4] ; TH1F* hmctruth_allsm[3][4] ; TH1F* hmctruth_all [3][4] ; for ( int si=0; si<nSel; si++ ) { for ( int bbi=0; bbi<nBinsBjets; bbi++ ) { char hname[1000] ; char htitle[1000] ; sprintf( htitle, "%s, %d btag", selname[si], bbi+1 ) ; sprintf( hname, "hmctruth_susy_%s_%db", selname[si], bbi+1 ) ; hmctruth_susy[si][bbi] = bookHist( hname, htitle, selname[si], bbi+1, nBinsMET, nBinsHT ) ; sprintf( hname, "hmctruth_ttwj_%s_%db", selname[si], bbi+1 ) ; hmctruth_ttwj[si][bbi] = bookHist( hname, htitle, selname[si], bbi+1, nBinsMET, nBinsHT ) ; sprintf( hname, "hmctruth_ttbar_%s_%db", selname[si], bbi+1 ) ; hmctruth_ttbar[si][bbi] = bookHist( hname, htitle, selname[si], bbi+1, nBinsMET, nBinsHT ) ; sprintf( hname, "hmctruth_wjets_%s_%db", selname[si], bbi+1 ) ; hmctruth_wjets[si][bbi] = bookHist( hname, htitle, selname[si], bbi+1, nBinsMET, nBinsHT ) ; sprintf( hname, "hmctruth_qcd_%s_%db", selname[si], bbi+1 ) ; hmctruth_qcd[si][bbi] = bookHist( hname, htitle, selname[si], bbi+1, nBinsMET, nBinsHT ) ; sprintf( hname, "hmctruth_znn_%s_%db", selname[si], bbi+1 ) ; hmctruth_znn[si][bbi] = bookHist( hname, htitle, selname[si], bbi+1, nBinsMET, nBinsHT ) ; sprintf( hname, "hmctruth_allsm_%s_%db", selname[si], bbi+1 ) ; hmctruth_allsm[si][bbi] = bookHist( hname, htitle, selname[si], bbi+1, nBinsMET, nBinsHT ) ; sprintf( hname, "hmctruth_all_%s_%db", selname[si], bbi+1 ) ; hmctruth_all[si][bbi] = bookHist( hname, htitle, selname[si], bbi+1, nBinsMET, nBinsHT ) ; } // bbi. } // si. TH1F* hmctruth_fit_zee_1b = bookHist("hmctruth_fit_zee_1b" , "Zee" , "Zee", 1, nBinsMET, nBinsHT ) ; TH1F* hmctruth_fit_zmm_1b = bookHist("hmctruth_fit_zmm_1b" , "Zmm" , "Zmm", 1, nBinsMET, nBinsHT ) ; //--- histograms used in getting the observables. TH2F* h_tt[10] ; TH2F* h_wjets[10] ; TH2F* h_qcd[10] ; TH2F* h_znn[10] ; TH2F* h_susy[10] ; TH2F* h_mc[10] ; for ( int bi=0; bi<nBinsBjets; bi++ ) { char hname[100] ; sprintf( hname, "h_tt_%db", bi+1 ) ; h_tt[bi] = new TH2F( hname, hname , nBinsMET, Mbins, nBinsHT, Hbins ) ; h_tt[bi] -> Sumw2() ; sprintf( hname, "h_wjets_%db", bi+1 ) ; h_wjets[bi] = new TH2F( hname, hname , nBinsMET, Mbins, nBinsHT, Hbins ) ; h_wjets[bi] -> Sumw2() ; sprintf( hname, "h_qcd_%db", bi+1 ) ; h_qcd[bi] = new TH2F( hname, hname , nBinsMET, Mbins, nBinsHT, Hbins ) ; h_qcd[bi] -> Sumw2() ; sprintf( hname, "h_znn_%db", bi+1 ) ; h_znn[bi] = new TH2F( hname, hname , nBinsMET, Mbins, nBinsHT, Hbins ) ; h_znn[bi] -> Sumw2() ; sprintf( hname, "h_susy_%db", bi+1 ) ; h_susy[bi] = new TH2F( hname, hname , nBinsMET, Mbins, nBinsHT, Hbins ) ; h_susy[bi] -> Sumw2() ; sprintf( hname, "h_mc_%db", bi+1 ) ; h_mc[bi] = new TH2F( hname, hname , nBinsMET, Mbins, nBinsHT, Hbins ) ; h_mc[bi] -> Sumw2() ; } float nSusyTotal = 0; for ( int si=0 ; si<nSel ; si++ ) { printf("\n\n-----------------------------------------------------------------\n\n") ; for (int k = 0 ; k < nBinsBjets ; k++) { char allcuts[10000] ; char allsusycuts[10000] ; if ( k < (nBinsBjets-1) ) { sprintf( allcuts, "%snB==%d&&nJets>=%d&&(pt_1st_leadJet>%.0f&&pt_2nd_leadJet>%.0f&&pt_3rd_leadJet>%.0f)", selcuts[si], k+1, nJetsCut, minLeadJetPt, minLeadJetPt, min3rdJetPt ) ; sprintf( allsusycuts, "%snB==%d&&nJets>=%d&&(pt_1st_leadJet>%.0f&&pt_2nd_leadJet>%.0f&&pt_3rd_leadJet>%.0f)%s", selcuts[si], k+1, nJetsCut, minLeadJetPt, minLeadJetPt, min3rdJetPt, susycut.Data() ) ; } else { sprintf( allcuts, "%snB>=%d&&nJets>=%d&&(pt_1st_leadJet>%.0f&&pt_2nd_leadJet>%.0f&&pt_3rd_leadJet>%.0f)", selcuts[si], k+1, nJetsCut, minLeadJetPt, minLeadJetPt, min3rdJetPt ) ; sprintf( allsusycuts, "%snB>=%d&&nJets>=%d&&(pt_1st_leadJet>%.0f&&pt_2nd_leadJet>%.0f&&pt_3rd_leadJet>%.0f)%s", selcuts[si], k+1, nJetsCut, minLeadJetPt, minLeadJetPt, min3rdJetPt, susycut.Data() ) ; } printf("\n\n N_%s -- nbjet bin (%d): cuts=%s\n\n", selname[si], k, allcuts) ; cout << flush ; char hname[100] ; sprintf( hname, "h_tt_%db", k+1 ) ; if(doPUreweighting) FillHTMET(&chainTT, h_tt[k], si, k); else chainTT.Project (hname,"HT:MET",allcuts); printf(" %12s %9.1f events\n", hname, h_tt[k]->Integral() ) ; cout << flush ; sprintf( hname, "h_wjets_%db", k+1 ) ; if(doPUreweighting) FillHTMET(&chainWJets, h_wjets[k], si, k); else chainWJets.Project(hname,"HT:MET",allcuts); printf(" %12s %9.1f events\n", hname, h_wjets[k]->Integral() ) ; cout << flush ; sprintf( hname, "h_qcd_%db", k+1 ) ; if (doPUreweighting) FillHTMET(&chainQCD, h_qcd[k], si, k); else chainQCD.Project(hname,"HT:MET",allcuts); printf(" %12s %9.1f events\n", hname, h_qcd[k]->Integral() ) ; cout << flush ; sprintf( hname, "h_znn_%db", k+1 ) ; if (doPUreweighting) FillHTMET(&chainZnn, h_znn[k], si, k); else chainZnn.Project(hname,"HT:MET",allcuts); printf(" %12s %9.1f events\n", hname, h_znn[k]->Integral() ) ; cout << flush ; if ( mgl > 0. ) { sprintf( hname, "h_susy_%db", k+1 ) ; chainT1bbbb.Project(hname,"HT:MET",allsusycuts); h_susy[k]->Scale( t1bbbbWeight ) ; printf(" %12s %9.1f events\n", hname, h_susy[k]->Integral() ) ; cout << flush ; if (si==0) nSusyTotal += h_susy[k]->Integral(); } } // k if (si==0) printf("N_Susy_Total = %9.1f events", nSusyTotal); cout << flush; printf("\n\n") ; for (int i = 0 ; i < nBinsMET ; i++) { for (int j = 0 ; j < nBinsHT ; j++) { for (int k = 0 ; k < nBinsBjets ; k++) { char obsname[1000] ; sprintf( obsname, "N_%s_M%d_H%d_%db", selname[si], i+1, j+1, k+1 ) ; double ttval = h_tt[k] -> GetBinContent( i+1, j+1 ) ; double tterr = h_tt[k] -> GetBinError( i+1, j+1 ) ; double wjetsval = h_wjets[k] -> GetBinContent( i+1, j+1 ) ; double wjetserr = h_wjets[k] -> GetBinError( i+1, j+1 ) ; double qcdval = h_qcd[k] -> GetBinContent( i+1, j+1 ) ; double qcderr = h_qcd[k] -> GetBinError( i+1, j+1 ) ; double znnval = h_znn[k] -> GetBinContent( i+1, j+1 ) ; double znnerr = h_znn[k] -> GetBinError( i+1, j+1 ) ; double susyval = h_susy[k] -> GetBinContent( i+1, j+1 ) ; double susyerr = h_susy[k] -> GetBinError( i+1, j+1 ) ; printf(" N_%s, tt met,ht,nbjet bin (%d,%d,%d) -- npass=%7.1f +/- %6.1f\n", selname[si], i,j,k, ttval,tterr) ; cout << flush ; printf(" N_%s, wjets met,ht,nbjet bin (%d,%d,%d) -- npass=%7.1f +/- %6.1f\n", selname[si], i,j,k, wjetsval,wjetserr) ; cout << flush ; printf(" N_%s, qcd met,ht,nbjet bin (%d,%d,%d) -- npass=%7.1f +/- %6.1f\n", selname[si], i,j,k, qcdval,qcderr) ; cout << flush ; printf(" N_%s, znn met,ht,nbjet bin (%d,%d,%d) -- npass=%7.1f +/- %6.1f\n", selname[si], i,j,k, znnval,znnerr) ; cout << flush ; if ( mgl>0. ) { if ( target_susy_all0lep > 0. ) { susyval = susyval * (target_susy_all0lep/nSusyTotal); susyerr = susyerr * (target_susy_all0lep/nSusyTotal); } printf(" N_%s, susy met,ht,nbjet bin (%d,%d,%d) -- npass=%7.1f +/- %6.1f\n", selname[si], i,j,k, susyval,susyerr) ; cout << flush ; } printf("\n") ; double allval = ttval + wjetsval + qcdval + znnval + susyval ; //// inFile << obsname << " \t" << (int)allval << endl; inFile << obsname << " \t" << allval << endl; int histbin = 1 + (nBinsHT+1)*i + j + 1 ; hmctruth_ttwj[si][k] -> SetBinContent( histbin, ttval + wjetsval ) ; hmctruth_ttwj[si][k] -> SetBinError( histbin, sqrt( pow(tterr,2) + pow(wjetserr,2) ) ) ; hmctruth_ttbar[si][k] -> SetBinContent( histbin, ttval ) ; hmctruth_ttbar[si][k] -> SetBinError( histbin, tterr ) ; hmctruth_wjets[si][k] -> SetBinContent( histbin, wjetsval ) ; hmctruth_wjets[si][k] -> SetBinError( histbin, wjetserr ) ; hmctruth_qcd[si][k] -> SetBinContent( histbin, qcdval ) ; hmctruth_qcd[si][k] -> SetBinError( histbin, qcderr ) ; hmctruth_znn[si][k] -> SetBinContent( histbin, znnval ) ; hmctruth_znn[si][k] -> SetBinError( histbin, znnerr ) ; hmctruth_susy[si][k] -> SetBinContent( histbin, susyval ) ; hmctruth_susy[si][k] -> SetBinError( histbin, susyerr ) ; hmctruth_allsm[si][k] -> SetBinContent( histbin, ttval+wjetsval+qcdval+znnval ) ; hmctruth_allsm[si][k] -> SetBinError( histbin, sqrt( pow(tterr,2) + pow(wjetserr,2) + pow(qcderr,2) + pow(znnerr,2) ) ) ; hmctruth_all[si][k] -> SetBinContent( histbin, ttval+wjetsval+qcdval+znnval+susyval ) ; hmctruth_all[si][k] -> SetBinError( histbin, sqrt( pow(tterr,2) + pow(wjetserr,2) + pow(qcderr,2) + pow(znnerr,2) + pow(susyerr,2) ) ) ; // compute fractions of SL 2b/1b and 3b/1b if ( si == 1 && k > 0 ) { double ttval_1b = h_tt[0] -> GetBinContent( i+1, j+1 ) ; double wjetsval_1b = h_wjets[0] -> GetBinContent( i+1, j+1 ) ; double ttwjval = ttval + wjetsval ; double ttwjval_1b = ttval_1b + wjetsval_1b ; if ( k == 1 ) { sl_frac2b_val[i][j] = ( ttwjval ) / ( ttwjval_1b ) ; sl_frac2b_err[i][j] = 0.01 ; // start with arbitrary errors, first } if ( k == 2 ) { sl_frac3b_val[i][j] = ( ttwjval ) / ( ttwjval_1b ) ; sl_frac3b_err[i][j] = 0.01 ; // start with arbitrary errors, first } if ( k == 3 ) { sl_frac4b_val[i][j] = ( ttwjval ) / ( ttwjval_1b ) ; sl_frac4b_err[i][j] = 0.01 ; // start with arbitrary errors, first } } } // k } // j } // i for (int k = 0 ; k < nBinsBjets ; k++) { h_tt[k] -> Reset() ; h_wjets[k] -> Reset() ; h_qcd[k] -> Reset() ; h_znn[k] -> Reset() ; h_susy[k] -> Reset() ; } } // si. //--- Insert dummy R_lsb lines for backwards compatibility. for ( int hbi=0; hbi<nBinsHT; hbi++ ) { for ( int bbi=0; bbi<nBinsBjets; bbi++ ) { char dummyline[1000] ; sprintf( dummyline, "R_lsb_H%d_%db 0.1", hbi+1, bbi+1 ) ; inFile << dummyline << endl ; sprintf( dummyline, "R_lsb_H%d_%db_err 0.01", hbi+1, bbi+1 ) ; inFile << dummyline << endl ; } // bbi. } // hbi. printf("\n\n-----------------------------------------------------------------\n\n") ; cout << flush ; { //--- scoping bracket for QCD chunk. //--- Fill histograms to be used in QCD analysis (done in mcclosure4.c). const int nQcdSamples(9) ; TCanvas* cqcd = new TCanvas("cqcd","QCD") ; TH2F* h0lep[nQcdSamples][nBinsBjets] ; TH2F* hldp [nQcdSamples][nBinsBjets] ; TChain* qcdch[nQcdSamples] ; char hname[1000] ; char htitle[1000] ; TH2F* hdummy = new TH2F("hdummy","",2, Mbins[0], 1500., 2, Hbins[0], 1500. ) ; printf("\n\n") ; for ( int si=0; si<nQcdSamples; si++ ) { qcdch[si] = new TChain("tree") ; printf(" %2d : connecting to %s\n", si, qcdinputfile[si] ) ; qcdch[si] -> Add( qcdinputfile[si] ) ; for ( int bbi=0; bbi<nBinsBjets; bbi++ ) { sprintf( hname, "h_0lep_%db_%s", bbi+1, qcdsamplename[si] ) ; sprintf( htitle, "QCD 0lep yield, nb=%d, %s", bbi+1, qcdsamplename[si] ) ; printf(" booking hist %s : %s\n", hname, htitle ) ; h0lep[si][bbi] = new TH2F( hname, htitle, nBinsMET, Mbins, nBinsHT, Hbins ) ; h0lep[si][bbi] -> Sumw2() ; sprintf( hname, "h_ldp_%db_%s", bbi+1, qcdsamplename[si] ) ; sprintf( htitle, "QCD LDP yield, nb=%d, %s", bbi+1, qcdsamplename[si] ) ; printf(" booking hist %s : %s\n", hname, htitle ) ; hldp [si][bbi] = new TH2F( hname, htitle, nBinsMET, Mbins, nBinsHT, Hbins ) ; hldp [si][bbi] -> Sumw2() ; } // bbi. } // si. printf("\n\n") ; char bcut[4][100] = { "nB==1", "nB==2", "nB==3", "nB>=4" } ; for ( int si=0; si<nQcdSamples; si++ ) { printf(" %2d : %s : 0lep\n", si, qcdsamplename[si] ) ; cout << flush ; for ( int bbi=0; bbi<nBinsBjets; bbi++ ) { char arg1[1000] ; char cuts0lep[10000] ; sprintf( cuts0lep, "%s(%s)&&nJets>=%d&&(pt_1st_leadJet>%.0f&&pt_2nd_leadJet>%.0f&&pt_3rd_leadJet>%.0f)", selcuts[0], bcut[bbi], nJetsCut, minLeadJetPt, minLeadJetPt, min3rdJetPt ) ; printf(" %db, 0lep cuts : %s\n", bbi+1, cuts0lep ) ; sprintf( arg1, "HT:MET>>h_0lep_%db_%s", bbi+1, qcdsamplename[si] ) ; qcdch[si] -> Draw( arg1, cuts0lep ) ; hdummy->Draw() ; h0lep[si][bbi]->Draw("samecolz") ; cqcd->Update() ; cqcd->Draw() ; char cutsldp[10000] ; sprintf( cutsldp, "%s(%s)&&nJets>=%d&&(pt_1st_leadJet>%.0f&&pt_2nd_leadJet>%.0f&&pt_3rd_leadJet>%.0f)", selcuts[2], bcut[bbi], nJetsCut, minLeadJetPt, minLeadJetPt, min3rdJetPt ) ; printf(" %db, ldp cuts : %s\n", bbi+1, cutsldp ) ; sprintf( arg1, "HT:MET>>h_ldp_%db_%s", bbi+1, qcdsamplename[si] ) ; qcdch[si] -> Draw( arg1, cutsldp, "colz" ) ; hdummy->Draw() ; hldp[si][bbi]->Draw("samecolz") ; cqcd->Update() ; cqcd->Draw() ; } // bbi. } // si. } //--- scoping bracket for QCD chunk. printf("\n\n-----------------------------------------------------------------\n\n") ; cout << flush ; // Z -> ee observables TH1F* ht = new TH1F("ht","ht",10,0,10000); ht -> Sumw2() ; TString cutszee = "cat==2&&minDelPhiNee>4&&nVLB>=1&&nJets>="; stringstream njcut ; njcut << nJetsCut ; cutszee += njcut.str(); cutszee += "&&"; for (int i = 0 ; i < nBinsMET ; i++) { for (int j = 0 ; j < nBinsHT ; j++) { TString obs_Zee = "N_Zee" ; obs_Zee = obs_Zee+sMbins[i]+sHbins[j] ; TString cut = "HT>"; cut += Hbins[j]; cut += "&&HT<"; cut += Hbins[j+1]; cut += "&&METee>"; cut += Mbins[i]; cut += "&&METee<"; cut += Mbins[i+1]; TString allcutsZ = cutszee+cut ; allcutsZ += "&&" ; allcutsZ += leadJetPtCutString ; dyTree->Project("ht","HT",allcutsZ); double allerr(0.) ; double allval = ht->IntegralAndError(1,10,allerr) ; printf(" N_Zee -- HT,MET bins (%d,%d): events=%7.1f +/- %6.1f, cuts=%s\n", j,i,allval,allerr,allcutsZ.Data() ) ; cout << flush ; ht->Reset() ; ////// inFile << obs_Zee << " \t" << (int)allval << endl; inFile << obs_Zee << " \t" << allval << endl; //Z->ee counts, with 1 VLb and sig selection, so so MET>250, HT>400, mindelphi>4, 2e, 0mu, nJets >= 3 int histbin = 1 + (nBinsHT+1)*i + j + 1 ; hmctruth_fit_zee_1b -> SetBinContent( histbin, allval ) ; hmctruth_fit_zee_1b -> SetBinError( histbin, allerr ) ; } } printf("\n\n-----------------------------------------------------------------\n\n") ; cout << flush ; // Z -> mm observables TString cutszmm = "cat==1&&minDelPhiNmm>4&&nVLB>=1&&nJets>="; cutszmm += njcut.str(); cutszmm += "&&"; for (int i = 0 ; i < nBinsMET ; i++) { for (int j = 0 ; j < nBinsHT ; j++) { TString obs_Zmm = "N_Zmm" ; obs_Zmm = obs_Zmm+sMbins[i]+sHbins[j] ; TString cut = "HT>"; cut += Hbins[j]; cut += "&&HT<"; cut += Hbins[j+1]; cut += "&&METmm>"; cut += Mbins[i]; cut += "&&METmm<"; cut += Mbins[i+1]; TString allcutsZ = cutszmm+cut ; allcutsZ += "&&" ; allcutsZ += leadJetPtCutString ; dyTree->Project("ht","HT",allcutsZ); double allerr(0.) ; double allval = ht->IntegralAndError(1,10,allerr) ; printf(" N_Zmm -- HT,MET bins (%d,%d): events=%7.1f +/- %6.1f, cuts=%s\n", j,i,allval,allerr,allcutsZ.Data() ) ; cout << flush ; ht->Reset() ; ////// inFile << obs_Zmm << " \t" << (int)allval << endl; inFile << obs_Zmm << " \t" << allval << endl; //Z->mm counts, with 1 VLb and sig selection, so so MET>250, HT>400, mindelphi>4, 2mu, 0e, nJets >= 3 int histbin = 1 + (nBinsHT+1)*i + j + 1 ; hmctruth_fit_zmm_1b -> SetBinContent( histbin, allval ) ; hmctruth_fit_zmm_1b -> SetBinError( histbin, allerr ) ; } } //inFile << "Why are all three of these MC categories separate? I've just put them together (only QCD, Zinv, tt)" << endl; // Nttbarsingletopzjetsmc_ldp printf("\n\n-----------------------------------------------------------------\n\n") ; cout << flush ; //--- Owen : these MC inputs are no longer used. Insert dummy values for backwards compatibility in format. for (int i = 0 ; i < nBinsMET ; i++) { for (int j = 0 ; j < nBinsHT ; j++) { for (int k = 0 ; k < nBinsBjets ; k++) { char obsname[1000] ; sprintf( obsname, "N_ttbarsingletopzjetsmc_ldp_M%d_H%d_%db", i+1, j+1, k+1 ) ; double val, err ; val = 0. ; err = 0. ; printf(" %s : %7.1f +/- %7.1f\n", obsname, val, err ) ; inFile << obsname << " \t" << val << endl ; } printf("\n") ; } printf("\n") ; } // NWJmc_ldp for (int i = 0 ; i < nBinsMET ; i++) { for (int j = 0 ; j < nBinsHT ; j++) { for (int k = 0 ; k < nBinsBjets ; k++) { TString obs_WJmc_ldp = "N_WJmc_ldp" ; obs_WJmc_ldp = obs_WJmc_ldp+sMbins[i]+sHbins[j]+sBbins[k] ; inFile << obs_WJmc_ldp << " \t" << dummyZero << endl; // signal selection, but ldp, so MET>250, HT>400, >=1 b, mindelphi<4, 0L, nJets >= 3 } } } // NZnnmc_ldp for (int i = 0 ; i < nBinsMET ; i++) { for (int j = 0 ; j < nBinsHT ; j++) { for (int k = 0 ; k < nBinsBjets ; k++) { TString obs_Znnmc_ldp = "N_Znnmc_ldp" ; obs_Znnmc_ldp = obs_Znnmc_ldp+sMbins[i]+sHbins[j]+sBbins[k] ; inFile << obs_Znnmc_ldp << " \t" << dummyZero << endl; // signal selection, but ldp, so MET>250, HT>400, >=1 b, mindelphi<4, 0L, nJets >= 3 } } } printf("\n\n-----------------------------------------------------------------\n\n") ; cout << flush ; // various parameters needed for Z -> invis. // Z -> ee acceptance for (int i = 0 ; i < nBinsMET ; i++) { TString Zee_acc = "acc_Zee"; Zee_acc = Zee_acc+sMbins[i]; inFile << Zee_acc << " \t" << dummyPoint999 << endl; Zee_acc = Zee_acc+"_err"; inFile << Zee_acc << " \t" << dummyErr << endl; } // Z -> mm acceptance for (int i = 0 ; i < nBinsMET ; i++) { TString Zmm_acc = "acc_Zmm"; Zmm_acc = Zmm_acc+sMbins[i]; inFile << Zmm_acc << " \t" << dummyPoint999 << endl; Zmm_acc = Zmm_acc+"_err"; inFile << Zmm_acc << " \t" << dummyErr << endl; } // Z -> ll efficiencies // use 2011 values for now. inFile << "Z_ee_eff \t" << 0.6774 << endl; inFile << "Z_ee_eff_err \t" << 0.0580 << endl; inFile << "Z_mm_eff \t" << 0.7217 << endl; inFile << "Z_mm_eff_err \t" << 0.0506 << endl; // Z -> ee VL to nominal scale factors // would it make more sense to count events in only the loosest HT and/or MET bin and // use the scale factors to translate between the different HT and MET bins? // for (int k = 0 ; k < nBinsBjets ; k++) { // TString knn_ee = "knn_ee" ; // knn_ee = knn_ee+sBbins[k] ; // inFile << knn_ee << " \t" << dummyOne << endl; // knn_ee = knn_ee+"_err" ; // inFile << knn_ee << " \t" << dummyErr << endl; // } // // // // use 2011 values for now. // inFile << "knn_1b \t" << 0.401 << endl; // inFile << "knn_1b_err \t" << 0.018 << endl; // inFile << "knn_2b \t" << 0.067 << endl; // inFile << "knn_2b_err \t" << 0.009 << endl; // inFile << "knn_3b \t" << 0.009 << endl; // inFile << "knn_3b_err \t" << 0.003 << endl; // // updated SF's to improve MC closure (the errors are the same as before) inFile << "knn_1b \t" << 0.394 << endl; inFile << "knn_1b_err \t" << 0.018 << endl; inFile << "knn_2b \t" << 0.0626 << endl; inFile << "knn_2b_err \t" << 0.009 << endl; inFile << "knn_3b \t" << 0.0036 << endl; inFile << "knn_3b_err \t" << 0.003 << endl; inFile << "knn_4b \t" << 0.00011 << endl; inFile << "knn_4b_err \t" << 0.00011 << endl; // Z -> ll purity // use 2011 values for now. inFile << "Z_ee_pur \t" << 0.911 << endl; inFile << "Z_ee_pur_err \t" << 0.079 << endl; inFile << "Z_mm_pur \t" << 0.866 << endl; inFile << "Z_mm_pur_err \t" << 0.079 << endl; // scale factors: inFile << "sf_mc \t" << dummyOne << endl ; inFile << "sf_mc_err \t" << dummyErr << endl; // sf_qcd for (int i = 0 ; i < nBinsMET ; i++) { for (int j = 0 ; j < nBinsHT ; j++) { for (int k = 0 ; k < nBinsBjets ; k++) { TString sf_qcd = "sf_qcd" ; sf_qcd = sf_qcd+sMbins[i]+sHbins[j]+sBbins[k] ; inFile << sf_qcd << " \t" << dummyOne << endl; sf_qcd = sf_qcd+"_err" ; inFile << sf_qcd << " \t" << dummyErr << endl; } } } // sf_ttwj for (int i = 0 ; i < nBinsMET ; i++) { for (int j = 0 ; j < nBinsHT ; j++) { for (int k = 0 ; k < nBinsBjets ; k++) { TString sf_ttwj = "sf_ttwj" ; sf_ttwj = sf_ttwj+sMbins[i]+sHbins[j]+sBbins[k] ; inFile << sf_ttwj << " \t" << dummyOne << endl; sf_ttwj = sf_ttwj+"_err" ; inFile << sf_ttwj << " \t" << dummyErr << endl; } } } // sf_ee for (int k = 0 ; k < nBinsBjets ; k++) { TString sf_ee = "sf_ee" ; sf_ee = sf_ee+sBbins[k] ; inFile << sf_ee << " \t" << dummyOne << endl; sf_ee = sf_ee+"_err" ; inFile << sf_ee << " \t" << dummyErr << endl; } // sf_mm for (int k = 0 ; k < nBinsBjets ; k++) { TString sf_mm = "sf_mm" ; sf_mm = sf_mm+sBbins[k] ; inFile << sf_mm << " \t" << dummyOne << endl; sf_mm = sf_mm+"_err" ; inFile << sf_mm << " \t" << dummyErr << endl; } // btag eff err (Note: this was missing until Aug 3, 2012, but it's apparently not used.) inFile << "btageff_err" << " \t" << dummyErr << endl ; //--- Addding ttwj and znn LDP/ZL MC values //--- ttwj MC LDP/ZL for (int mbi = 0 ; mbi < nBinsMET ; mbi++) { for (int hbi = 0 ; hbi < nBinsHT ; hbi++) { int hbin = 1 + (nBinsHT+1)*mbi + hbi + 1 ; for (int bbi = 0 ; bbi < nBinsBjets ; bbi++) { float ldpval = hmctruth_ttwj[2][bbi] -> GetBinContent( hbin ) ; float ldperr = hmctruth_ttwj[2][bbi] -> GetBinError( hbin ) ; float zlval = hmctruth_ttwj[0][bbi] -> GetBinContent( hbin ) ; float zlerr = hmctruth_ttwj[0][bbi] -> GetBinError( hbin ) ; float ldpoverzl = 0. ; float ldpoverzlerr = 0. ; if ( zlval > 0. && ldpval > 0. ) { ldpoverzl = ldpval / zlval ; ldpoverzlerr = ldpoverzl * sqrt( pow((zlerr/zlval),2) + pow((ldperr/ldpval),2) ) ; } char parname[1000] ; sprintf( parname, "ttwj_mc_ldpover0lep_ratio_M%d_H%d_%db", mbi+1, hbi+1, bbi+1 ) ; printf(" %s : %6.3f +/- %5.3f\n", parname, ldpoverzl, ldpoverzlerr ) ; inFile << parname << " \t" << ldpoverzl << endl; sprintf( parname, "ttwj_mc_ldpover0lep_ratio_M%d_H%d_%db_err", mbi+1, hbi+1, bbi+1 ) ; inFile << parname << " \t" << ldpoverzlerr << endl; } // bbi } // hbi } // mbi //--- Znn MC LDP/ZL //--- Note: the 2b and >=3b MC stats are too low. Use 1b values for all 3. for (int mbi = 0 ; mbi < nBinsMET ; mbi++) { for (int hbi = 0 ; hbi < nBinsHT ; hbi++) { int hbin = 1 + (nBinsHT+1)*mbi + hbi + 1 ; float ldpval = hmctruth_znn[2][0] -> GetBinContent( hbin ) ; float ldperr = hmctruth_znn[2][0] -> GetBinError( hbin ) ; float zlval = hmctruth_znn[0][0] -> GetBinContent( hbin ) ; float zlerr = hmctruth_znn[0][0] -> GetBinError( hbin ) ; float ldpoverzl = 0. ; float ldpoverzlerr = 0. ; if ( zlval > 0. && ldpval > 0. ) { ldpoverzl = ldpval / zlval ; ldpoverzlerr = ldpoverzl * sqrt( pow((zlerr/zlval),2) + pow((ldperr/ldpval),2) ) ; } char parname[1000] ; for (int bbi = 0 ; bbi < nBinsBjets ; bbi++) { sprintf( parname, "znn_mc_ldpover0lep_ratio_M%d_H%d_%db", mbi+1, hbi+1, bbi+1 ) ; printf(" %s : %6.3f +/- %5.3f\n", parname, ldpoverzl, ldpoverzlerr ) ; inFile << parname << " \t" << ldpoverzl << endl; sprintf( parname, "znn_mc_ldpover0lep_ratio_M%d_H%d_%db_err", mbi+1, hbi+1, bbi+1 ) ; inFile << parname << " \t" << ldpoverzlerr << endl; } // bbi } // hbi } // mbi // add here the fractions (bin by bin) of 2b/1b and 3b/1b SL events (just for the MC for now) for (int mbi = 0 ; mbi < nBinsMET ; mbi++) { for (int hbi = 0 ; hbi < nBinsHT ; hbi++) { TString Sl2bstring = "sl_frac_2b_val"; TString Sl2bstring_err = "sl_frac_2b_err"; TString Sl3bstring = "sl_frac_3b_val"; TString Sl3bstring_err = "sl_frac_3b_err"; TString Sl4bstring = "sl_frac_4b_val"; TString Sl4bstring_err = "sl_frac_4b_err"; Sl2bstring += sMbins[mbi]+sHbins[hbi] ; Sl2bstring_err += sMbins[mbi]+sHbins[hbi] ; Sl3bstring += sMbins[mbi]+sHbins[hbi] ; Sl3bstring_err += sMbins[mbi]+sHbins[hbi] ; Sl4bstring += sMbins[mbi]+sHbins[hbi] ; Sl4bstring_err += sMbins[mbi]+sHbins[hbi] ; inFile << Sl2bstring << " \t" << sl_frac2b_val[mbi][hbi] << endl ; inFile << Sl2bstring_err << " \t" << sl_frac2b_err[mbi][hbi] << endl ; inFile << Sl3bstring << " \t" << sl_frac3b_val[mbi][hbi] << endl ; inFile << Sl3bstring_err << " \t" << sl_frac3b_err[mbi][hbi] << endl ; inFile << Sl4bstring << " \t" << sl_frac4b_val[mbi][hbi] << endl ; inFile << Sl4bstring_err << " \t" << sl_frac4b_err[mbi][hbi] << endl ; } } gSystem->Exec("mkdir -p rootfiles") ; char outHistName[1000] ; if ( mgl>0. && mlsp>0. ) { if ( target_susy_all0lep > 0 ) { sprintf( outHistName, "rootfiles/gi-plots-nb4-wsusy-mgl%.0f-mlsp%.0f-%.0fevts-met%d-ht%d-v%d.root", mgl, mlsp, target_susy_all0lep, nBinsMET, nBinsHT, version ) ; } else { sprintf( outHistName, "rootfiles/gi-plots-nb4-wsusy-mgl%.0f-mlsp%.0f-met%d-ht%d-v%d.root", mgl, mlsp, nBinsMET, nBinsHT, version ) ; } } else { sprintf( outHistName, "rootfiles/gi-plots-nb4-met%d-ht%d-v%d.root", nBinsMET, nBinsHT, version ) ; } saveHist( outHistName, "h*" ) ; inFile.close(); return; }
int Plot_tauPt_Stage1_DD() { double totalMC =0.0; double lumi= 35.865; //20.011 ; // B->5.882 // C->2.646 D->4.353 ; // E->4.049 ; F->3.16 ; G->7.554; H->5.942 //--inv fb--// unsigned long long evt_DYJetsToLL_M50=1; unsigned long long evt_DYJetsToLL_M5to50=1; unsigned long long evt_TT=1; TFile *file_DYJetsToLL_M50 = new TFile("../python/crab_projects_March3/crab_DYJetsToLL_M-50_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/results/hist.root"); double xs_DYJetsToLL_M50=4895000; //--fb--// TFile *file_DYJetsToLL_M5to50 = new TFile("../python/crab_projects_March3/crab_DYJetsToLL_M-10to50_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/results/hist.root"); double xs_DYJetsToLL_M5to50=7160000; //--fb--// TFile *file_TT = new TFile("../python/crab_projects_March3/crab_TT_TuneCUETP8M2T4_13TeV-powheg-pythia8/results/hist.root"); double xs_TT=730000; //--fb--// double kfact_TT= 1.139; TFile *file_TT_Mtt_700to1000 = new TFile("../python/crab_projects_March3/crab_TT_Mtt-700to1000_TuneCUETP8M1_13TeV-powheg-pythia8/results/hist.root"); double xs_TT_Mtt_700to1000=730000; //--fb--// double kfact_TT_Mtt_700to1000= 0.0921; TFile *file_TT_Mtt_1000toInf = new TFile("../python/crab_projects_March3/crab_TT_Mtt-1000toInf_TuneCUETP8M1_13TeV-powheg-pythia8/results/hist.root"); double xs_TT_Mtt_1000toInf=730000; //--fb--// double kfact_TT_Mtt_1000toInf= 0.02474; //TFile *file_WJetsToLNu = new TFile("../python/crab_projects_March3/crab_WJetsToLNu_TuneCUETP8M1_13TeV-amcatnloFXFX-pythia8/results/hist.root"); //double xs_WJetsToLNu=60290000; //--fb--// TFile *file_WJetsToLNu = new TFile("../python/crab_projects_March3/crab_WJetsToLNu_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/results/hist.root"); double xs_WJetsToLNu= 50690000; //--fb--// // TFile *file_WToTauNu_M100 = new TFile("../python/crab_projects_March3/crab_WToTauNu_M-100_TuneCUETP8M1_13TeV-pythia8-tauola/results/hist.root"); double xs_WToTauNu_M100 = 165000; //--fb--// double kfact_WToTauNu_M100 = 1.0 ; // TFile *file_WToTauNu_M200 = new TFile("../python/crab_projects_March3/crab_WToTauNu_M-200_TuneCUETP8M1_13TeV-pythia8-tauola/results/hist.root"); double xs_WToTauNu_M200 = 6370; //--fb--// double kfact_WToTauNu_M200 = 1.0 ; // TFile *file_WToTauNu_M500 = new TFile("../python/crab_projects_March3/crab_WToTauNu_M-500_TuneCUETP8M1_13TeV-pythia8-tauola/results/hist.root"); double xs_WToTauNu_M500 = 224.0; //--fb--// double kfact_WToTauNu_M500 = 1.0 ; // TFile *file_WToTauNu_M1000 = new TFile("../python/crab_projects_March3/crab_WToTauNu_M-1000_TuneCUETP8M1_13TeV-pythia8-tauola/results/hist.root"); double xs_WToTauNu_M1000 = 13.7; //--fb--// double kfact_WToTauNu_M1000 = 1.0 ; // TFile *file_WToTauNu_M2000 = new TFile("../python/crab_projects_March3/crab_WToTauNu_M-2000_TuneCUETP8M1_13TeV-pythia8-tauola/results/hist.root"); double xs_WToTauNu_M2000 = 0.437; //--fb--// double kfact_WToTauNu_M2000 = 1.0 ; // TFile *file_WToTauNu_M3000 = new TFile("../python/crab_projects_March3/crab_WToTauNu_M-3000_TuneCUETP8M1_13TeV-pythia8-tauola/results/hist.root"); double xs_WToTauNu_M3000 = 0.0342; //--fb--// double kfact_WToTauNu_M3000 = 1.0 ; // TFile *file_WToTauNu_M4000 = new TFile("../python/crab_projects_March3/crab_WToTauNu_M-4000_TuneCUETP8M1_13TeV-pythia8-tauola/results/hist.root"); double xs_WToTauNu_M4000 = 0.00292; //--fb--// double kfact_WToTauNu_M4000 = 1.0 ; // TFile *file_WToTauNu_M5000 = new TFile("../python/crab_projects_March3/crab_WToTauNu_M-5000_TuneCUETP8M1_13TeV-pythia8-tauola/results/hist.root"); double xs_WToTauNu_M5000 = 0.000233; //--fb--// double kfact_WToTauNu_M5000 = 1.0 ; // TFile *file_WToTauNu_M6000 = new TFile("../python/crab_projects_March3/crab_WToTauNu_M-6000_TuneCUETP8M1_13TeV-pythia8-tauola/results/hist.root"); double xs_WToTauNu_M6000 = 0.000015; //--fb--// double kfact_WToTauNu_M6000 = 1.0 ; // TFile *file_WJetsToLNu_HT100To200 = new TFile("../python/crab_projects_March3/crab_WJetsToLNu_HT-100To200_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/results/hist.root"); double xs_WJetsToLNu_HT100To200 = 1345000 ; //--fb--// double kfact_WJetsToLNu_HT100To200 = 1.0 ; TFile *file_WJetsToLNu_HT200To400 = new TFile("../python/crab_projects_March3/crab_WJetsToLNu_HT-200To400_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/results/hist.root"); double xs_WJetsToLNu_HT200To400 = 359700 ; //--fb--// double kfact_WJetsToLNu_HT200To400 = 1.0 ; TFile *file_WJetsToLNu_HT400To600 = new TFile("../python/crab_projects_March3/crab_WJetsToLNu_HT-400To600_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/results/hist.root"); double xs_WJetsToLNu_HT400To600 = 48910 ; //--fb--// double kfact_WJetsToLNu_HT400To600 = 1.0 ; TFile *file_WJetsToLNu_HT600To800 = new TFile("../python/crab_projects_March3/crab_WJetsToLNu_HT-600To800_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/results/hist.root"); double xs_WJetsToLNu_HT600To800 = 12050 ; //--fb--// double kfact_WJetsToLNu_HT600To800 = 1.0 ; TFile *file_WJetsToLNu_HT800To1200 = new TFile("../python/crab_projects_March3/crab_WJetsToLNu_HT-800To1200_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/results/hist.root"); double xs_WJetsToLNu_HT800To1200 = 5501 ; //--fb--// double kfact_WJetsToLNu_HT800To1200 = 1.0 ; TFile *file_WJetsToLNu_HT1200To2500 = new TFile("../python/crab_projects_March3/crab_WJetsToLNu_HT-1200To2500_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/results/hist.root"); double xs_WJetsToLNu_HT1200To2500 = 1329 ; //--fb--// double kfact_WJetsToLNu_HT1200To2500 = 1.0 ; TFile *file_WJetsToLNu_HT2500ToInf = new TFile("../python/crab_projects_March3/crab_WJetsToLNu_HT-2500ToInf_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/results/hist.root"); double xs_WJetsToLNu_HT2500ToInf = 32.16 ; //--fb--// double kfact_WJetsToLNu_HT2500ToInf = 1.0 ; TFile *file_ST_tchannel_antitop=new TFile("../python/crab_projects_March3/crab_ST_t-channel_antitop_4f_inclusiveDecays_TuneCUETP8M2T4_13TeV-powhegV2-madspin/results/hist.root"); double xs_ST_tchannel_antitop = 80950; //--fb--// double kfact_ST_tchannel_antitop = 1.0; //0.326; // TFile *file_ST_tchannel_top=new TFile("../python/crab_projects_March3/crab_ST_t-channel_top_4f_inclusiveDecays_TuneCUETP8M2T4_13TeV-powhegV2-madspin/results/hist.root"); double xs_ST_tchannel_top =136020; //103200; //--fb--// double kfact_ST_tchannel_top = 1.0; //0.43; // TFile *file_ST_tW_antitop=new TFile("../python/crab_projects_March3/crab_ST_tW_antitop_5f_inclusiveDecays_13TeV-powheg-pythia8_TuneCUETP8M2T4/results/hist.root"); double xs_ST_tW_antitop = 38090; //--fb--// double kfact_ST_tW_antitop =1.0; // 0.94; // TFile *file_ST_tW_top=new TFile("../python/crab_projects_March3/crab_ST_tW_top_5f_inclusiveDecays_13TeV-powheg-pythia8_TuneCUETP8M2T4/results/hist.root"); double xs_ST_tW_top = 38090; //--fb--// double kfact_ST_tW_top = 1.0; //0.94; // TFile *file_WW=new TFile("../python/crab_projects_March3/crab_WW_TuneCUETP8M1_13TeV-pythia8/results/hist.root"); double xs_WW = 63210; //--fb--// // TFile *file_WZ=new TFile("../python/crab_projects_March3/crab_WZ_TuneCUETP8M1_13TeV-pythia8/results/hist.root"); double xs_WZ = 22820; //--fb--// double kfact_WZ = 2.06; // 47.13/22.82 // TFile *file_ZZ=new TFile("../python/crab_projects_March3/crab_ZZ_TuneCUETP8M1_13TeV-pythia8/results/hist.root"); double xs_ZZ = 10320; //--fb--// double kfact_ZZ = 1.60 ; //16523/10320 // std::cout << "get datadriven root file" << std::endl; TFile *file_Datadriven = new TFile("/net/scratch_cms3a/materok/wprime/qcd/dataDrivenTree15_pt_base_Mar7_fromData.root"); /// DATA /// TFile *file_Tau_Run2016B = new TFile("../python/crab_projects_March3/crab_Tau_Run2016B/results/hist.root"); TFile *file_Tau_Run2016C = new TFile("../python/crab_projects_March3/crab_Tau_Run2016C/results/hist.root"); TFile *file_Tau_Run2016D = new TFile("../python/crab_projects_March3/crab_Tau_Run2016D/results/hist.root"); TFile *file_Tau_Run2016E = new TFile("../python/crab_projects_March3/crab_Tau_Run2016E/results/hist.root"); TFile *file_Tau_Run2016F = new TFile("../python/crab_projects_March3/crab_Tau_Run2016F/results/hist.root"); TFile *file_Tau_Run2016G = new TFile("../python/crab_projects_March3/crab_Tau_Run2016G/results/hist.root"); TFile *file_Tau_Run2016H_v2 = new TFile("../python/crab_projects_March3/crab_Tau_Run2016H_1/results/hist.root"); TFile *file_Tau_Run2016H_v3 = new TFile("../python/crab_projects_March3/crab_Tau_Run2016H_2/results/hist.root"); /// Signal /// TFile *file_Wprime_M4000 = new TFile("../python/crab_projects_March3/crab_WprimeToTauNu_M-4000_TuneCUETP8M1_13TeV-pythia8-tauola/results/hist.root"); double xs_Wprime_M4000= 2.04; // --fb-- // //--// TH1D* h1_evt_DYJetsToLL_M50 = (TH1D*)file_DYJetsToLL_M50->Get("demo/histoDir/eventCount"); evt_DYJetsToLL_M50 = h1_evt_DYJetsToLL_M50->GetEntries(); // Integral(); double wt_DYJetsToLL_M50 = (xs_DYJetsToLL_M50*lumi)/evt_DYJetsToLL_M50 ; TH1D* tauPt_Stage1_DYJetsToLL_M50 = (TH1D*)file_DYJetsToLL_M50->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_DYJetsToLL_M50->Scale(wt_DYJetsToLL_M50); std::cout << "DYJetsToLL_M50 weighted nevt=" << tauPt_Stage1_DYJetsToLL_M50->Integral() << std::endl; totalMC += tauPt_Stage1_DYJetsToLL_M50->Integral(); TH1D* h1_evt_DYJetsToLL_M5to50 = (TH1D*)file_DYJetsToLL_M5to50->Get("demo/histoDir/eventCount"); evt_DYJetsToLL_M5to50 = h1_evt_DYJetsToLL_M5to50->GetEntries(); // Integral(); double wt_DYJetsToLL_M5to50 = (xs_DYJetsToLL_M5to50*lumi)/evt_DYJetsToLL_M5to50 ; TH1D* tauPt_Stage1_DYJetsToLL_M5to50 = (TH1D*)file_DYJetsToLL_M5to50->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_DYJetsToLL_M5to50->Scale(wt_DYJetsToLL_M5to50); std::cout << "DYJetsToLL_M5to50 weighted nevt=" << tauPt_Stage1_DYJetsToLL_M5to50->Integral() << std::endl; totalMC += tauPt_Stage1_DYJetsToLL_M5to50->Integral() ; // TH1D* total_DY = (TH1D*)tauPt_Stage1_DYJetsToLL_M50->Clone(); total_DY->Add(tauPt_Stage1_DYJetsToLL_M5to50); total_DY->SetFillColorAlpha(kRed,0.5); total_DY->SetLineColor(kBlack); total_DY->Rebin(10); // TH1D* h1_evt_TT = (TH1D*)file_TT->Get("demo/histoDir/eventCount"); evt_TT = h1_evt_TT->GetEntries(); // Integral(); double wt_TT = (xs_TT*lumi)/evt_TT ; TH1D* tauPt_Stage1_TT = (TH1D*)file_TT->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_TT->Scale(wt_TT); tauPt_Stage1_TT->Scale(kfact_TT); std::cout << "TTbar weighted nevt=" << tauPt_Stage1_TT->Integral() << std::endl; totalMC += tauPt_Stage1_TT->Integral(); //file_TT_Mtt_700to1000 TH1D* h1_evt_TT_Mtt_700to1000 = (TH1D*)file_TT_Mtt_700to1000->Get("demo/histoDir/eventCount"); evt_TT_Mtt_700to1000 = h1_evt_TT_Mtt_700to1000->GetEntries(); // Integral(); double wt_TT_Mtt_700to1000 = (xs_TT_Mtt_700to1000*lumi)/evt_TT_Mtt_700to1000 ; TH1D* tauPt_Stage1_TT_Mtt_700to1000 = (TH1D*)file_TT_Mtt_700to1000->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_TT_Mtt_700to1000->Scale(wt_TT_Mtt_700to1000); tauPt_Stage1_TT_Mtt_700to1000->Scale(kfact_TT_Mtt_700to1000); std::cout << "TT_Mtt_700to1000bar weighted nevt=" << tauPt_Stage1_TT_Mtt_700to1000->Integral() << std::endl; totalMC += tauPt_Stage1_TT_Mtt_700to1000->Integral() ; //file_TT_Mtt_1000toInf TH1D* h1_evt_TT_Mtt_1000toInf = (TH1D*)file_TT_Mtt_1000toInf->Get("demo/histoDir/eventCount"); evt_TT_Mtt_1000toInf = h1_evt_TT_Mtt_1000toInf->GetEntries(); // Integral(); double wt_TT_Mtt_1000toInf = (xs_TT_Mtt_1000toInf*lumi)/evt_TT_Mtt_1000toInf ; TH1D* tauPt_Stage1_TT_Mtt_1000toInf = (TH1D*)file_TT_Mtt_1000toInf->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_TT_Mtt_1000toInf->Scale(wt_TT_Mtt_1000toInf); tauPt_Stage1_TT_Mtt_1000toInf->Scale(kfact_TT_Mtt_1000toInf); std::cout << "TT_Mtt_1000toInfbar weighted nevt=" << tauPt_Stage1_TT_Mtt_1000toInf->Integral() << std::endl; totalMC += tauPt_Stage1_TT_Mtt_1000toInf->Integral() ; TH1D* total_TT = (TH1D*)tauPt_Stage1_TT->Clone(); total_TT->Add(tauPt_Stage1_TT_Mtt_700to1000); total_TT->Add(tauPt_Stage1_TT_Mtt_1000toInf); total_TT->SetFillColor(kBlue-7); total_TT->SetLineColor(kBlack); total_TT->Rebin(10); /* TH1D* h1_evt_WJetsToLNu = (TH1D*)file_WJetsToLNu->Get("demo/histoDir/eventCount"); evt_WJetsToLNu = h1_evt_WJetsToLNu->GetEntries(); //Integral(); std::cout << "evt_WJetsToLNu = " << evt_WJetsToLNu << std::endl; double wt_WJetsToLNu = (xs_WJetsToLNu*lumi)/evt_WJetsToLNu ; TH1D* tauPt_Stage1_WJetsToLNu = (TH1D*)file_WJetsToLNu->Get("demo/histoDir/tauPt_Stage1"); // Poisson error // tauPt_Stage1_WJetsToLNu->Sumw2(kFALSE); tauPt_Stage1_WJetsToLNu->SetBinErrorOption(TH1::kPoisson); std::cout << "**WJets** unweighted nevt=" << tauPt_Stage1_WJetsToLNu->Integral() << std::endl; std::cout << "wt_WJetsToLNu = " << wt_WJetsToLNu << std::endl; tauPt_Stage1_WJetsToLNu->Scale(wt_WJetsToLNu); tauPt_Stage1_WJetsToLNu->SetFillColorAlpha(kGreen-7,0.5); tauPt_Stage1_WJetsToLNu->SetLineColor(kGreen-7); tauPt_Stage1_WJetsToLNu->Rebin(40); std::cout << "**WJets** weighted nevt=" << tauPt_Stage1_WJetsToLNu->Integral() << std::endl; */ //file_ST_tchannel_antitop TH1D* h1_evt_ST_tchannel_antitop = (TH1D*)file_ST_tchannel_antitop->Get("demo/histoDir/eventCount"); unsigned long long evt_ST_tchannel_antitop = h1_evt_ST_tchannel_antitop->GetEntries(); //Integral(); double wt_ST_tchannel_antitop = (xs_ST_tchannel_antitop*lumi)/evt_ST_tchannel_antitop ; TH1D* tauPt_Stage1_ST_tchannel_antitop = (TH1D*)file_ST_tchannel_antitop->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_ST_tchannel_antitop->Scale(wt_ST_tchannel_antitop); tauPt_Stage1_ST_tchannel_antitop->Scale(kfact_ST_tchannel_antitop); std::cout << "ST_tchannel_antitop weighted nevt=" << tauPt_Stage1_ST_tchannel_antitop->Integral() << std::endl; totalMC += tauPt_Stage1_ST_tchannel_antitop->Integral(); //file_ST_tchannel_top TH1D* h1_evt_ST_tchannel_top = (TH1D*)file_ST_tchannel_top->Get("demo/histoDir/eventCount"); unsigned long long evt_ST_tchannel_top = h1_evt_ST_tchannel_top->GetEntries(); //Integral(); double wt_ST_tchannel_top = (xs_ST_tchannel_top*lumi)/evt_ST_tchannel_top ; TH1D* tauPt_Stage1_ST_tchannel_top = (TH1D*)file_ST_tchannel_top->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_ST_tchannel_top->Scale(wt_ST_tchannel_top); tauPt_Stage1_ST_tchannel_top->Scale(kfact_ST_tchannel_top); std::cout << "ST_tchannel_top weighted nevt=" << tauPt_Stage1_ST_tchannel_top->Integral() << std::endl; totalMC += tauPt_Stage1_ST_tchannel_top->Integral() ; //file_ST_tW_antitop TH1D* h1_evt_ST_tW_antitop = (TH1D*)file_ST_tW_antitop->Get("demo/histoDir/eventCount"); unsigned long long evt_ST_tW_antitop = h1_evt_ST_tW_antitop->GetEntries(); //Integral(); double wt_ST_tW_antitop = (xs_ST_tW_antitop*lumi)/evt_ST_tW_antitop ; TH1D* tauPt_Stage1_ST_tW_antitop = (TH1D*)file_ST_tW_antitop->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_ST_tW_antitop->Scale(wt_ST_tW_antitop); tauPt_Stage1_ST_tW_antitop->Scale(kfact_ST_tW_antitop); std::cout << "ST_tW_antitop weighted nevt=" << tauPt_Stage1_ST_tW_antitop->Integral() << std::endl; totalMC += tauPt_Stage1_ST_tW_antitop->Integral(); //file_ST_tW_top TH1D* h1_evt_ST_tW_top = (TH1D*)file_ST_tW_top->Get("demo/histoDir/eventCount"); unsigned long long evt_ST_tW_top = h1_evt_ST_tW_top->GetEntries(); //Integral(); double wt_ST_tW_top = (xs_ST_tW_top*lumi)/evt_ST_tW_top ; TH1D* tauPt_Stage1_ST_tW_top = (TH1D*)file_ST_tW_top->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_ST_tW_top->Scale(wt_ST_tW_top); tauPt_Stage1_ST_tW_top->Scale(kfact_ST_tW_top); std::cout << "ST_tW_top weighted nevt=" << tauPt_Stage1_ST_tW_top->Integral() << std::endl; totalMC += tauPt_Stage1_ST_tW_top->Integral() ; TH1D* total_ST = (TH1D*)tauPt_Stage1_ST_tchannel_antitop->Clone(); total_ST->Add(tauPt_Stage1_ST_tchannel_top); total_ST->Add(tauPt_Stage1_ST_tW_antitop); total_ST->Add(tauPt_Stage1_ST_tW_top); total_ST->SetFillColorAlpha(kCyan,0.5); total_ST->SetLineColor(kBlack); total_ST->Rebin(10); //file_WJetsToLNu_HT100To200 TH1D* h1_evt_WJetsToLNu_HT100To200 = (TH1D*)file_WJetsToLNu_HT100To200->Get("demo/histoDir/eventCount"); unsigned long long evt_WJetsToLNu_HT100To200 = h1_evt_WJetsToLNu_HT100To200->GetEntries(); //Integral(); double wt_WJetsToLNu_HT100To200 = (xs_WJetsToLNu_HT100To200*lumi)/evt_WJetsToLNu_HT100To200 ; TH1D* tauPt_Stage1_WJetsToLNu_HT100To200 = (TH1D*)file_WJetsToLNu_HT100To200->Get("demo/histoDir/tauPt_Stage1"); // Poisson error // // tauPt_Stage1_WJetsToLNu_HT100To200->Sumw2(kFALSE); //tauPt_Stage1_WJetsToLNu_HT100To200->SetBinErrorOption(TH1::kPoisson); tauPt_Stage1_WJetsToLNu_HT100To200->Scale(wt_WJetsToLNu_HT100To200); std::cout << "WJetsToLNu_HT100To200 weighted nevt=" << tauPt_Stage1_WJetsToLNu_HT100To200->Integral() << std::endl; totalMC += tauPt_Stage1_WJetsToLNu_HT100To200->Integral(); //tauPt_Stage1_WJetsToLNu_HT100To200->Scale(kfact_WJetsToLNu_HT100To200); // std::cout << tauPt_Stage1_WJetsToLNu_HT100To200->GetBinError(300) << std::endl; //file_WJetsToLNu_HT200To400 TH1D* h1_evt_WJetsToLNu_HT200To400 = (TH1D*)file_WJetsToLNu_HT200To400->Get("demo/histoDir/eventCount"); unsigned long long evt_WJetsToLNu_HT200To400 = h1_evt_WJetsToLNu_HT200To400->GetEntries(); //Integral(); double wt_WJetsToLNu_HT200To400 = (xs_WJetsToLNu_HT200To400*lumi)/evt_WJetsToLNu_HT200To400 ; TH1D* tauPt_Stage1_WJetsToLNu_HT200To400 = (TH1D*)file_WJetsToLNu_HT200To400->Get("demo/histoDir/tauPt_Stage1"); // Poisson error // // tauPt_Stage1_WJetsToLNu_HT200To400->Sumw2(kFALSE); //tauPt_Stage1_WJetsToLNu_HT200To400->SetBinErrorOption(TH1::kPoisson); tauPt_Stage1_WJetsToLNu_HT200To400->Scale(wt_WJetsToLNu_HT200To400); std::cout << "WJetsToLNu_HT200To400 weighted nevt=" << tauPt_Stage1_WJetsToLNu_HT200To400->Integral() << std::endl; totalMC += tauPt_Stage1_WJetsToLNu_HT200To400->Integral(); //tauPt_Stage1_WJetsToLNu_HT200To400->Scale(kfact_WJetsToLNu_HT200To400); //std::cout << tauPt_Stage1_WJetsToLNu_HT200To400->GetBinError(300) << std::endl; //file_WJetsToLNu_HT400To600 TH1D* h1_evt_WJetsToLNu_HT400To600 = (TH1D*)file_WJetsToLNu_HT400To600->Get("demo/histoDir/eventCount"); unsigned long long evt_WJetsToLNu_HT400To600 = h1_evt_WJetsToLNu_HT400To600->GetEntries(); //Integral(); double wt_WJetsToLNu_HT400To600 = (xs_WJetsToLNu_HT400To600*lumi)/evt_WJetsToLNu_HT400To600 ; TH1D* tauPt_Stage1_WJetsToLNu_HT400To600 = (TH1D*)file_WJetsToLNu_HT400To600->Get("demo/histoDir/tauPt_Stage1"); // Poisson error // // tauPt_Stage1_WJetsToLNu_HT400To600->Sumw2(kFALSE); //tauPt_Stage1_WJetsToLNu_HT400To600->SetBinErrorOption(TH1::kPoisson); tauPt_Stage1_WJetsToLNu_HT400To600->Scale(wt_WJetsToLNu_HT400To600); std::cout << "WJetsToLNu_HT400To600 weighted nevt=" << tauPt_Stage1_WJetsToLNu_HT400To600->Integral() << std::endl; totalMC += tauPt_Stage1_WJetsToLNu_HT400To600->Integral(); // tauPt_Stage1_WJetsToLNu_HT400To600->Scale(kfact_WJetsToLNu_HT400To600); // std::cout << tauPt_Stage1_WJetsToLNu_HT400To600->GetBinError(300) << std::endl; //file_WJetsToLNu_HT600To800 TH1D* h1_evt_WJetsToLNu_HT600To800 = (TH1D*)file_WJetsToLNu_HT600To800->Get("demo/histoDir/eventCount"); unsigned long long evt_WJetsToLNu_HT600To800 = h1_evt_WJetsToLNu_HT600To800->GetEntries(); //Integral(); double wt_WJetsToLNu_HT600To800 = (xs_WJetsToLNu_HT600To800*lumi)/evt_WJetsToLNu_HT600To800 ; TH1D* tauPt_Stage1_WJetsToLNu_HT600To800 = (TH1D*)file_WJetsToLNu_HT600To800->Get("demo/histoDir/tauPt_Stage1"); // Poisson error // // tauPt_Stage1_WJetsToLNu_HT600To800->Sumw2(kFALSE); // tauPt_Stage1_WJetsToLNu_HT600To800->SetBinErrorOption(TH1::kPoisson); tauPt_Stage1_WJetsToLNu_HT600To800->Scale(wt_WJetsToLNu_HT600To800); std::cout << "WJetsToLNu_HT600To800 weighted nevt=" << tauPt_Stage1_WJetsToLNu_HT600To800->Integral() << std::endl; totalMC += tauPt_Stage1_WJetsToLNu_HT600To800->Integral(); // tauPt_Stage1_WJetsToLNu_HT600To800->Scale(kfact_WJetsToLNu_HT600To800); // std::cout << tauPt_Stage1_WJetsToLNu_HT600To800->GetBinError(300) << std::endl; //file_WJetsToLNu_HT800To1200 TH1D* h1_evt_WJetsToLNu_HT800To1200 = (TH1D*)file_WJetsToLNu_HT800To1200->Get("demo/histoDir/eventCount"); unsigned long long evt_WJetsToLNu_HT800To1200 = h1_evt_WJetsToLNu_HT800To1200->GetEntries(); //Integral(); double wt_WJetsToLNu_HT800To1200 = (xs_WJetsToLNu_HT800To1200*lumi)/evt_WJetsToLNu_HT800To1200 ; TH1D* tauPt_Stage1_WJetsToLNu_HT800To1200 = (TH1D*)file_WJetsToLNu_HT800To1200->Get("demo/histoDir/tauPt_Stage1"); // Poisson error // // tauPt_Stage1_WJetsToLNu_HT800To1200->Sumw2(kFALSE); //tauPt_Stage1_WJetsToLNu_HT800To1200->SetBinErrorOption(TH1::kPoisson); tauPt_Stage1_WJetsToLNu_HT800To1200->Scale(wt_WJetsToLNu_HT800To1200); std::cout << "WJetsToLNu_HT800To1200 weighted nevt=" << tauPt_Stage1_WJetsToLNu_HT800To1200->Integral() << std::endl; totalMC += tauPt_Stage1_WJetsToLNu_HT800To1200->Integral(); //tauPt_Stage1_WJetsToLNu_HT800To1200->Scale(kfact_WJetsToLNu_HT800To1200); // std::cout << tauPt_Stage1_WJetsToLNu_HT800To1200->GetBinError(300) << std::endl; //file_WJetsToLNu_HT1200To2500 TH1D* h1_evt_WJetsToLNu_HT1200To2500 = (TH1D*)file_WJetsToLNu_HT1200To2500->Get("demo/histoDir/eventCount"); unsigned long long evt_WJetsToLNu_HT1200To2500 = h1_evt_WJetsToLNu_HT1200To2500->GetEntries(); //Integral(); double wt_WJetsToLNu_HT1200To2500 = (xs_WJetsToLNu_HT1200To2500*lumi)/evt_WJetsToLNu_HT1200To2500 ; TH1D* tauPt_Stage1_WJetsToLNu_HT1200To2500 = (TH1D*)file_WJetsToLNu_HT1200To2500->Get("demo/histoDir/tauPt_Stage1"); // Poisson error // // tauPt_Stage1_WJetsToLNu_HT1200To2500->Sumw2(kFALSE); //tauPt_Stage1_WJetsToLNu_HT1200To2500->SetBinErrorOption(TH1::kPoisson); tauPt_Stage1_WJetsToLNu_HT1200To2500->Scale(wt_WJetsToLNu_HT1200To2500); std::cout << "WJetsToLNu_HT1200To2500 weighted nevt=" << tauPt_Stage1_WJetsToLNu_HT1200To2500->Integral() << std::endl; totalMC += tauPt_Stage1_WJetsToLNu_HT1200To2500->Integral(); // tauPt_Stage1_WJetsToLNu_HT1200To2500->Scale(kfact_WJetsToLNu_HT1200To2500); //std::cout << tauPt_Stage1_WJetsToLNu_HT1200To2500->GetBinError(300) << std::endl; //file_WJetsToLNu_HT2500ToInf TH1D* h1_evt_WJetsToLNu_HT2500ToInf = (TH1D*)file_WJetsToLNu_HT2500ToInf->Get("demo/histoDir/eventCount"); unsigned long long evt_WJetsToLNu_HT2500ToInf = h1_evt_WJetsToLNu_HT2500ToInf->GetEntries(); //Integral(); double wt_WJetsToLNu_HT2500ToInf = (xs_WJetsToLNu_HT2500ToInf*lumi)/evt_WJetsToLNu_HT2500ToInf ; TH1D* tauPt_Stage1_WJetsToLNu_HT2500ToInf = (TH1D*)file_WJetsToLNu_HT2500ToInf->Get("demo/histoDir/tauPt_Stage1"); // Poisson error // //tauPt_Stage1_WJetsToLNu_HT2500ToInf->Sumw2(kFALSE); //tauPt_Stage1_WJetsToLNu_HT2500ToInf->SetBinErrorOption(TH1::kPoisson); tauPt_Stage1_WJetsToLNu_HT2500ToInf->Scale(wt_WJetsToLNu_HT2500ToInf); std::cout << "WJetsToLNu_HT2500ToInf weighted nevt=" << tauPt_Stage1_WJetsToLNu_HT2500ToInf->Integral() << std::endl; totalMC += tauPt_Stage1_WJetsToLNu_HT2500ToInf->Integral(); //tauPt_Stage1_WJetsToLNu_HT2500ToInf->Scale(kfact_WJetsToLNu_HT2500ToInf); ///std::cout << tauPt_Stage1_WJetsToLNu_HT2500ToInf->GetBinError(300) << std::endl; //file_WToTauNu_M100 TH1D* h1_evt_WToTauNu_M100 = (TH1D*)file_WToTauNu_M100->Get("demo/histoDir/eventCount"); unsigned long long evt_WToTauNu_M100 = h1_evt_WToTauNu_M100->GetEntries(); //Integral(); double wt_WToTauNu_M100 = (xs_WToTauNu_M100*lumi)/evt_WToTauNu_M100 ; TH1D* tauPt_Stage1_WToTauNu_M100 = (TH1D*)file_WToTauNu_M100->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_WToTauNu_M100->Scale(wt_WToTauNu_M100); std::cout << "WToTauNu_M100 weighted nevt=" << tauPt_Stage1_WToTauNu_M100->Integral() << std::endl; totalMC += tauPt_Stage1_WToTauNu_M100->Integral() ; //file_WToTauNu_M200 TH1D* h1_evt_WToTauNu_M200 = (TH1D*)file_WToTauNu_M200->Get("demo/histoDir/eventCount"); unsigned long long evt_WToTauNu_M200 = h1_evt_WToTauNu_M200->GetEntries(); //Integral(); double wt_WToTauNu_M200 = (xs_WToTauNu_M200*lumi)/evt_WToTauNu_M200 ; TH1D* tauPt_Stage1_WToTauNu_M200 = (TH1D*)file_WToTauNu_M200->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_WToTauNu_M200->Scale(wt_WToTauNu_M200); std::cout << "WToTauNu_M200 weighted nevt=" << tauPt_Stage1_WToTauNu_M200->Integral() << std::endl; totalMC += tauPt_Stage1_WToTauNu_M200->Integral(); //file_WToTauNu_M500 TH1D* h1_evt_WToTauNu_M500 = (TH1D*)file_WToTauNu_M500->Get("demo/histoDir/eventCount"); unsigned long long evt_WToTauNu_M500 = h1_evt_WToTauNu_M500->GetEntries(); //Integral(); double wt_WToTauNu_M500 = (xs_WToTauNu_M500*lumi)/evt_WToTauNu_M500 ; TH1D* tauPt_Stage1_WToTauNu_M500 = (TH1D*)file_WToTauNu_M500->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_WToTauNu_M500->Scale(wt_WToTauNu_M500); std::cout << "WToTauNu_M500 weighted nevt=" << tauPt_Stage1_WToTauNu_M500->Integral() << std::endl; totalMC += tauPt_Stage1_WToTauNu_M500->Integral() ; //file_WToTauNu_M1000 TH1D* h1_evt_WToTauNu_M1000 = (TH1D*)file_WToTauNu_M1000->Get("demo/histoDir/eventCount"); unsigned long long evt_WToTauNu_M1000 = h1_evt_WToTauNu_M1000->GetEntries(); //Integral(); double wt_WToTauNu_M1000 = (xs_WToTauNu_M1000*lumi)/evt_WToTauNu_M1000 ; TH1D* tauPt_Stage1_WToTauNu_M1000 = (TH1D*)file_WToTauNu_M1000->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_WToTauNu_M1000->Scale(wt_WToTauNu_M1000); std::cout << "WToTauNu_M1000 weighted nevt=" << tauPt_Stage1_WToTauNu_M1000->Integral() << std::endl; totalMC += tauPt_Stage1_WToTauNu_M1000->Integral(); //file_WToTauNu_M2000 TH1D* h1_evt_WToTauNu_M2000 = (TH1D*)file_WToTauNu_M2000->Get("demo/histoDir/eventCount"); unsigned long long evt_WToTauNu_M2000 = h1_evt_WToTauNu_M2000->GetEntries(); //Integral(); double wt_WToTauNu_M2000 = (xs_WToTauNu_M2000*lumi)/evt_WToTauNu_M2000 ; TH1D* tauPt_Stage1_WToTauNu_M2000 = (TH1D*)file_WToTauNu_M2000->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_WToTauNu_M2000->Scale(wt_WToTauNu_M2000); std::cout << "WToTauNu_M2000 weighted nevt=" << tauPt_Stage1_WToTauNu_M2000->Integral() << std::endl; totalMC += tauPt_Stage1_WToTauNu_M2000->Integral(); //file_WToTauNu_M3000 TH1D* h1_evt_WToTauNu_M3000 = (TH1D*)file_WToTauNu_M3000->Get("demo/histoDir/eventCount"); unsigned long long evt_WToTauNu_M3000 = h1_evt_WToTauNu_M3000->GetEntries(); //Integral(); double wt_WToTauNu_M3000 = (xs_WToTauNu_M3000*lumi)/evt_WToTauNu_M3000 ; TH1D* tauPt_Stage1_WToTauNu_M3000 = (TH1D*)file_WToTauNu_M3000->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_WToTauNu_M3000->Scale(wt_WToTauNu_M3000); std::cout << "WToTauNu_M3000 weighted nevt=" << tauPt_Stage1_WToTauNu_M3000->Integral() << std::endl; totalMC += tauPt_Stage1_WToTauNu_M3000->Integral(); //file_WToTauNu_M4000 TH1D* h1_evt_WToTauNu_M4000 = (TH1D*)file_WToTauNu_M4000->Get("demo/histoDir/eventCount"); unsigned long long evt_WToTauNu_M4000 = h1_evt_WToTauNu_M4000->GetEntries(); //Integral(); double wt_WToTauNu_M4000 = (xs_WToTauNu_M4000*lumi)/evt_WToTauNu_M4000 ; TH1D* tauPt_Stage1_WToTauNu_M4000 = (TH1D*)file_WToTauNu_M4000->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_WToTauNu_M4000->Scale(wt_WToTauNu_M4000); std::cout << "WToTauNu_M4000 weighted nevt=" << tauPt_Stage1_WToTauNu_M4000->Integral() << std::endl; totalMC += tauPt_Stage1_WToTauNu_M4000->Integral(); //file_WToTauNu_M5000 TH1D* h1_evt_WToTauNu_M5000 = (TH1D*)file_WToTauNu_M5000->Get("demo/histoDir/eventCount"); unsigned long long evt_WToTauNu_M5000 = h1_evt_WToTauNu_M5000->GetEntries(); //Integral(); double wt_WToTauNu_M5000 = (xs_WToTauNu_M5000*lumi)/evt_WToTauNu_M5000 ; TH1D* tauPt_Stage1_WToTauNu_M5000 = (TH1D*)file_WToTauNu_M5000->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_WToTauNu_M5000->Scale(wt_WToTauNu_M5000); std::cout << "WToTauNu_M5000 weighted nevt=" << tauPt_Stage1_WToTauNu_M5000->Integral() << std::endl; totalMC += tauPt_Stage1_WToTauNu_M5000->Integral(); //file_WToTauNu_M6000 TH1D* h1_evt_WToTauNu_M6000 = (TH1D*)file_WToTauNu_M6000->Get("demo/histoDir/eventCount"); unsigned long long evt_WToTauNu_M6000 = h1_evt_WToTauNu_M6000->GetEntries(); //Integral(); double wt_WToTauNu_M6000 = (xs_WToTauNu_M6000*lumi)/evt_WToTauNu_M6000 ; TH1D* tauPt_Stage1_WToTauNu_M6000 = (TH1D*)file_WToTauNu_M6000->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_WToTauNu_M6000->Scale(wt_WToTauNu_M6000); std::cout << "WToTauNu_M6000 weighted nevt=" << tauPt_Stage1_WToTauNu_M6000->Integral() << std::endl; totalMC += tauPt_Stage1_WToTauNu_M6000->Integral(); //file_WJetsToLNu TH1D* h1_evt_WJetsToLNu = (TH1D*)file_WJetsToLNu->Get("demo/histoDir/eventCount"); unsigned long long evt_WJetsToLNu = h1_evt_WJetsToLNu->GetEntries(); //Integral(); double wt_WJetsToLNu = (xs_WJetsToLNu*lumi)/evt_WJetsToLNu ; TH1D* tauPt_Stage1_WJetsToLNu = (TH1D*)file_WJetsToLNu->Get("demo/histoDir/tauPt_Stage1"); tauPt_Stage1_WJetsToLNu->Scale(wt_WJetsToLNu); std::cout << "WJetsToLNu weighted nevt=" << tauPt_Stage1_WJetsToLNu->Integral() << std::endl; totalMC += tauPt_Stage1_WJetsToLNu->Integral(); TH1D* total_WJets = (TH1D*)tauPt_Stage1_WJetsToLNu_HT100To200->Clone(); total_WJets->Add(tauPt_Stage1_WJetsToLNu_HT200To400); total_WJets->Add(tauPt_Stage1_WJetsToLNu_HT400To600); total_WJets->Add(tauPt_Stage1_WJetsToLNu_HT600To800); total_WJets->Add(tauPt_Stage1_WJetsToLNu_HT800To1200); total_WJets->Add(tauPt_Stage1_WJetsToLNu_HT1200To2500); total_WJets->Add(tauPt_Stage1_WJetsToLNu_HT2500ToInf); total_WJets->Add(tauPt_Stage1_WToTauNu_M100); total_WJets->Add(tauPt_Stage1_WToTauNu_M200); total_WJets->Add(tauPt_Stage1_WToTauNu_M500); total_WJets->Add(tauPt_Stage1_WToTauNu_M1000); total_WJets->Add(tauPt_Stage1_WToTauNu_M2000); total_WJets->Add(tauPt_Stage1_WToTauNu_M3000); total_WJets->Add(tauPt_Stage1_WToTauNu_M4000); total_WJets->Add(tauPt_Stage1_WToTauNu_M5000); total_WJets->Add(tauPt_Stage1_WToTauNu_M6000); total_WJets->Add(tauPt_Stage1_WJetsToLNu); total_WJets->SetFillColorAlpha(kGreen-8,0.5); total_WJets->SetLineColor(kBlack); //std::cout << "Wjets " << total_WJets->GetBinError(300) << std::endl; total_WJets->Rebin(10); //file_WW TH1D* h1_evt_WW = (TH1D*)file_WW->Get("demo/histoDir/eventCount"); unsigned long long evt_WW = h1_evt_WW->GetEntries(); //Integral(); double wt_WW = (xs_WW*lumi)/evt_WW ; TH1D* tauPt_Stage1_WW = (TH1D*)file_WW->Get("demo/histoDir/tauPt_Stage1"); // Poisson error // //tauPt_Stage1_WW->Sumw2(kFALSE); //tauPt_Stage1_WW->SetBinErrorOption(TH1::kPoisson); tauPt_Stage1_WW->Scale(wt_WW); std::cout << "WW weighted nevt=" << tauPt_Stage1_WW->Integral() << std::endl; totalMC +=tauPt_Stage1_WW->Integral() ; //file_WZ TH1D* h1_evt_WZ = (TH1D*)file_WZ->Get("demo/histoDir/eventCount"); unsigned long long evt_WZ = h1_evt_WZ->GetEntries(); //Integral(); double wt_WZ = (xs_WZ*lumi)/evt_WZ ; TH1D* tauPt_Stage1_WZ = (TH1D*)file_WZ->Get("demo/histoDir/tauPt_Stage1"); // Poisson error // //tauPt_Stage1_WZ->Sumw2(kFALSE); // tauPt_Stage1_WZ->SetBinErrorOption(TH1::kPoisson); tauPt_Stage1_WZ->Scale(wt_WZ); tauPt_Stage1_WZ->Scale(kfact_WZ); std::cout << "WZ weighted nevt=" << tauPt_Stage1_WZ->Integral() << std::endl; totalMC += tauPt_Stage1_WZ->Integral(); //file_ZZ TH1D* h1_evt_ZZ = (TH1D*)file_ZZ->Get("demo/histoDir/eventCount"); unsigned long long evt_ZZ = h1_evt_ZZ->GetEntries(); //Integral(); double wt_ZZ = (xs_ZZ*lumi)/evt_ZZ ; TH1D* tauPt_Stage1_ZZ = (TH1D*)file_ZZ->Get("demo/histoDir/tauPt_Stage1"); // Poisson error // //tauPt_Stage1_ZZ->Sumw2(kFALSE); //tauPt_Stage1_ZZ->SetBinErrorOption(TH1::kPoisson); tauPt_Stage1_ZZ->Scale(wt_ZZ); tauPt_Stage1_ZZ->Scale(kfact_ZZ); std::cout << "ZZ weighted nevt=" << tauPt_Stage1_ZZ->Integral() << std::endl; totalMC += tauPt_Stage1_ZZ->Integral(); TH1D* total_diboson = (TH1D*)tauPt_Stage1_WW->Clone(); total_diboson->Add(tauPt_Stage1_WZ); total_diboson->Add(tauPt_Stage1_ZZ); total_diboson->SetFillColorAlpha(kOrange+2,0.5); total_diboson->SetLineColor(kBlack); total_diboson->Rebin(10); //datadriven // double wt_Datadriven = (lumi/33.507) ; TH1D* total_QCD = (TH1D*)file_Datadriven->Get("demo/histoDir/tauPt_Stage1"); total_QCD->SetFillStyle(3001); total_QCD->SetFillColor(kPink+1); total_QCD->SetLineColor(kBlack); total_QCD->Rebin(10); //datadriven std::cout << "totalMC(w/o DD) =" << totalMC << std::endl; std::cout << "will do data" << std::endl; //--Data--// TH1D* tauPt_Stage1_Run2016F = (TH1D*)file_Tau_Run2016F->Get("demo/histoDir/tauPt_Stage1"); TH1D* tauPt_Stage1_Run2016E = (TH1D*)file_Tau_Run2016E->Get("demo/histoDir/tauPt_Stage1"); TH1D* tauPt_Stage1_Run2016D = (TH1D*)file_Tau_Run2016D->Get("demo/histoDir/tauPt_Stage1"); TH1D* tauPt_Stage1_Run2016C = (TH1D*)file_Tau_Run2016C->Get("demo/histoDir/tauPt_Stage1"); TH1D* tauPt_Stage1_Run2016B = (TH1D*)file_Tau_Run2016B->Get("demo/histoDir/tauPt_Stage1"); TH1D* tauPt_Stage1_Run2016G = (TH1D*)file_Tau_Run2016G->Get("demo/histoDir/tauPt_Stage1"); TH1D* tauPt_Stage1_Run2016H_v2 = (TH1D*)file_Tau_Run2016H_v2->Get("demo/histoDir/tauPt_Stage1"); TH1D* tauPt_Stage1_Run2016H_v3 = (TH1D*)file_Tau_Run2016H_v3->Get("demo/histoDir/tauPt_Stage1"); /* std::cout << "Will Clone B" << std::endl; TH1D* tauPt_Stage1_Run2016BCD = (TH1D*)tauPt_Stage1_Run2016B->Clone(); std::cout << "Will add C" << std::endl; tauPt_Stage1_Run2016BCD->Add(tauPt_Stage1_Run2016C); std::cout << "Will add D" << std::endl; tauPt_Stage1_Run2016BCD->Add(tauPt_Stage1_Run2016D); // std::cout << "Will add E" << std::endl; // tauPt_Stage1_Run2016BCDEF->Add(tauPt_Stage1_Run2016E); // std::cout << "Will add F" << std::endl; // tauPt_Stage1_Run2016BCDEF->Add(tauPt_Stage1_Run2016F); */ TH1D* tauPt_Stage1_Run2016all = (TH1D*)tauPt_Stage1_Run2016B->Clone(); tauPt_Stage1_Run2016all->Add(tauPt_Stage1_Run2016C); tauPt_Stage1_Run2016all->Add(tauPt_Stage1_Run2016D); tauPt_Stage1_Run2016all->Add(tauPt_Stage1_Run2016E); tauPt_Stage1_Run2016all->Add(tauPt_Stage1_Run2016F); tauPt_Stage1_Run2016all->Add(tauPt_Stage1_Run2016G); tauPt_Stage1_Run2016all->Add(tauPt_Stage1_Run2016H_v2); tauPt_Stage1_Run2016all->Add(tauPt_Stage1_Run2016H_v3); tauPt_Stage1_Run2016all->SetMarkerStyle(20); tauPt_Stage1_Run2016all->SetMarkerColor(kBlack); tauPt_Stage1_Run2016all->SetLineColor(kBlack); tauPt_Stage1_Run2016all->Rebin(10); std::cout << "will do signal " << std::endl; //--Signal--// TH1D* h1_evt_Wprime_M4000 = (TH1D*)file_Wprime_M4000->Get("demo/histoDir/eventCount"); unsigned long long evt_Wprime_M4000 = h1_evt_Wprime_M4000->GetEntries(); //Integral(); // std::cout << "evt_Wprime_M4000 = " << evt_Wprime_M4000 << std::endl; double wt_Wprime_M4000 = (xs_Wprime_M4000*lumi)/evt_Wprime_M4000 ; TH1D* tauPt_Stage1_Wprime_M4000 = (TH1D*)file_Wprime_M4000->Get("demo/histoDir/tauPt_Stage1"); std::cout << "Sig Eff W' M4000 : " << ( tauPt_Stage1_Wprime_M4000->GetEntries() / evt_Wprime_M4000 ) << std::endl; tauPt_Stage1_Wprime_M4000->Scale(wt_Wprime_M4000); // tauPt_Stage1_Wprime_M4000->SetFillColorAlpha(kGreen-7,0.5); tauPt_Stage1_Wprime_M4000->SetLineColor(kMagenta); tauPt_Stage1_Wprime_M4000->SetLineWidth(2); tauPt_Stage1_Wprime_M4000->SetLineStyle(5); tauPt_Stage1_Wprime_M4000->Rebin(10) ; //--Plotting Styles// gStyle->SetPadLeftMargin(0.15); gStyle->SetPadRightMargin(0.05); gStyle->SetPadBottomMargin(0.12); gStyle->SetPadTopMargin(0.05); gStyle->SetTitleXSize(0.05); gStyle->SetTitleXOffset(1.05); gStyle->SetTitleYSize(0.05); gStyle->SetTitleYOffset(1.05); //////// Output File ///////// TFile* outputFile = new TFile("Out_tauPt_Stage1.root","RECREATE"); outputFile->cd(); //--// THStack *hs = new THStack("hs",""); // hs->Add(tauPt_Stage1_WJetsToLNu); hs->Add(total_diboson); hs->Add(total_DY); hs->Add(total_ST); hs->Add(total_TT); // hs->Add(tauPt_Stage1_DYJetsToLL_M50); hs->Add(total_QCD); // hs->Add(total_ZJets); hs->Add(total_WJets); //tauPt_Stage1_->SetTitle(""); /* eff1->GetYaxis()->SetTitle("Events"); //eff1->SetMarkerStyle(0); //eff1->SetMarkerColor(kBlack); eff1->SetLineColor(kBlack); eff1->SetLineWidth(2); */ TCanvas* my_canvas = new TCanvas("canvas","canvas",800,600); my_canvas->cd(); // hs->Draw(); gPad->SetLogy(); hs->Draw("HIST"); hs->SetMaximum(100000); hs->SetMinimum(0.1); hs->GetXaxis()->SetRangeUser(0, 1000); // hs->GetXaxis()->SetLimits(40, 3200); hs->GetXaxis()->SetTitle("#tau pT [GeV]"); hs->GetYaxis()->SetTitle("Events"); TH1F* total = (TH1F*)hs->GetStack()->Last()->Clone(); // total->SetFillStyle(3004); // total->SetFillColor(kGray+1); // total->SetMarkerColor(0); // total->Draw("SAME E2"); //hs->GetStack()->Last()->Draw("same E"); // hs->Draw("SAME HIST"); // tauPt_Stage1_Run2016E->Draw("SAME E0"); tauPt_Stage1_Run2016all->Draw("SAME E0"); TH1F* mydata = (TH1F*)tauPt_Stage1_Run2016all->Clone(); //tauPt_Stage1_Run2016C->Draw("SAME E0"); //tauPt_Stage1_Run2016CDE->Draw("SAME E0"); // tauPt_Stage1_Wprime_M4000->Draw("SAME HIST"); // hs->SetOption("HIST L"); TLatex* CMS_text = new TLatex(0.20,0.90,"CMS"); CMS_text->SetNDC(); CMS_text->SetTextSize(0.05); CMS_text->SetTextAngle(0); CMS_text->Draw("same"); TLatex* CMS_text_2 = new TLatex(0.20,0.85,"Preliminary"); CMS_text_2->SetNDC(); CMS_text_2->SetTextFont(42); CMS_text_2->SetTextSize(0.05); CMS_text_2->SetTextAngle(0); CMS_text_2->Draw("same"); TLatex* lumiText = new TLatex(0.92,0.975,"35.9 fb^{-1} (13 TeV)"); lumiText->SetNDC(); lumiText->SetTextFont(42); lumiText->SetTextSize(0.04); lumiText->SetTextAlign(32); lumiText->Draw("same"); TLegend *leg_example = new TLegend(0.75,0.50,0.94,0.94); leg_example->SetFillColor(0); leg_example->SetTextFont(42); leg_example->SetBorderSize(0); leg_example->AddEntry(total_WJets, "Wjets","f"); leg_example->AddEntry(total_DY, "DY","f"); leg_example->AddEntry(total_TT, "TT","f"); //leg_example->AddEntry(tauPt_Stage1_WJetsToLNu, "Wjets","f"); leg_example->AddEntry(total_ST, "Single Top", "f"); leg_example->AddEntry(total_diboson, "Diboson", "f"); leg_example->AddEntry(total_QCD, "QCD datadriven", "f"); // leg_example->AddEntry(total_ZJets, "Z", "f"); leg_example->AddEntry(tauPt_Stage1_Wprime_M4000, "SSM W' 4 TeV", "l"); leg_example->AddEntry(tauPt_Stage1_Run2016all, "Data", "pl" ); // leg_example->AddEntry(tauPt_Stage1_Run2016E, "Data", "pl" ); // leg_example->AddEntry(tauPt_Stage1_Run2016D, "Data", "pl" ); leg_example->Draw("same"); my_canvas->Write(); my_canvas->Print("tauPt_Stage1_DD.pdf"); /* TCanvas* my_canvas2 = new TCanvas("canvas2","canvas2"); my_canvas2->cd(); gPad->SetLogy(); total->SetMaximum(1000); total->SetMarkerStyle(20); total->Draw("E"); my_canvas2->Write(); */ TCanvas* ratio_c = new TCanvas("ratio","ratio_canvas",800,700); ratio_c->SetTopMargin(0.); ratio_c->SetBottomMargin(0.); ratio_c->Update(); ratio_c->Divide(1, 2); ratio_c->cd(1); gPad->SetPad(.005, .30, .995, .995); TPad* pad1 = (TPad*)ratio_c->GetPad(1); pad1->SetTopMargin(0.05); pad1->SetBottomMargin(0.05); ratio_c->Update(); gPad->SetLogy(); hs->Draw("HIST"); hs->SetMaximum(100000); hs->SetMinimum(0.01); // hs->GetXaxis()->SetLimits(40, 3200); hs->GetXaxis()->SetRangeUser(0, 1000); hs->GetXaxis()->SetTitle(""); // total->Draw("SAME E2"); mydata->Draw("SAME E1"); tauPt_Stage1_Wprime_M4000->Draw("SAME HIST"); CMS_text->Draw("same"); CMS_text_2->Draw("same"); lumiText->Draw("same"); leg_example->Draw("same"); ratio_c->cd(2); gPad->SetPad(.005, .08, .995, .28); gStyle->SetOptStat(false); ratio_c->Update(); TPad* pad2 = (TPad*)ratio_c->GetPad(2); pad2->SetTopMargin(0.04); pad2->SetBottomMargin(0.30); pad2->SetGridx(); pad2->SetGridy(); std::cout << "data bins = " << mydata->GetNbinsX() << " width=" << mydata->GetBinWidth(2); std::cout << " MC bins = " << total->GetNbinsX() << " width=" << total->GetBinWidth(2) << std::endl; int nbin=mydata->GetNbinsX() ; float width=mydata->GetBinWidth(2); TH1F *data_by_MC = new TH1F("h1", "ratio", nbin, 0, 4000); std::cout << "before D/MC bins=" << data_by_MC->GetNbinsX() << " width=" << data_by_MC->GetBinWidth(2) << std::endl; for (int i=0; i<nbin; i++) { float data = mydata->GetBinContent(i); float MC = total->GetBinContent(i); float ratio=0; if (MC>0) ratio=data/MC ; data_by_MC->SetBinContent(i,ratio); if (data>0) { float stat_err = sqrt(data)/data ; data_by_MC->SetBinError(i,stat_err); } // data_by_MC->SetBinWidth(i,width); } // TH1F* data_by_MC = (TH1F*)mydata->Clone(); // data_by_MC->Divide(total); data_by_MC->SetMarkerStyle(20); data_by_MC->Draw("E"); data_by_MC->GetXaxis()->SetTitle("#tau pT [GeV]"); data_by_MC->GetYaxis()->SetTitle("#frac{DATA}{MC}"); data_by_MC->GetYaxis()->SetLabelSize(0.12); data_by_MC->GetXaxis()->SetLabelSize(0.12); data_by_MC->GetYaxis()->SetTitleSize(0.18); data_by_MC->GetXaxis()->SetTitleSize(0.18); data_by_MC->GetYaxis()->SetTitleOffset(0.20); data_by_MC->GetXaxis()->SetTitleOffset(0.75); data_by_MC->SetTitle(""); data_by_MC->GetXaxis()->SetRangeUser(0, 1000); data_by_MC->SetMaximum(4); data_by_MC->SetMinimum(0); data_by_MC->GetYaxis()->SetNdivisions(4); TLine *l=new TLine(0,1,1000,1); l->SetLineColor(kRed); l->Draw("same"); std::cout << "D/MC bins=" << data_by_MC->GetNbinsX() << " width=" << data_by_MC->GetBinWidth(2) << std::endl; ratio_c->Write(); ratio_c->Print("tauPt_Stage1_ratio_DD.pdf"); return 0; }
void Skim(TString fname="ZnnH125", TString outputname = "") { gROOT->LoadMacro("HelperFunctions.h" ); // make functions visible to TTreeFormula gROOT->SetBatch(1); TChain * chain = new TChain("tree"); TString dijet = ""; TString outdir = "/afs/cern.ch/work/d/degrutto/public/MiniAOD/ZnnHbb_Phys14_PU20bx25/skimV11_v2/"; TString prefix = "skim_"; TString suffix = "tree*.root"; TCut selection = baseline.c_str(); // Different baseline for dimuons // MET filters selection += metfilter.c_str(); // JSON & trigger if (fname.Contains("Data")) { TCut trigger = mettrigger.c_str(); selection += trigger; //selection.Print(); } /* } else if (process == "Data_METBTag_R" || process == "Data_METBTag_P") { TCut trigger = metbtagtrigger.c_str(); selection += trigger; //selection.Print(); } else if (process == "Data_SingleMu_R" || process == "Data_SingleMu_P") { TCut trigger = singlemutrigger.c_str(); selection += trigger; //selection.Print(); } else if (process == "Data_SingleEl_R" || process == "Data_SingleEl_P") { TCut trigger = singleeltrigger.c_str(); selection += trigger; //selection.Print(); } */ chain->Add(fname); // Sum Count, CountWithPU, CountWithPUP, CountWithPUM TObjArray * files = chain->GetListOfFiles(); TIter next(files); TChainElement * chainElem = 0; TFile * f2 = 0; TH1D * h1 = new TH1D("Count", ";Counts", 16, 0, 16); TH1F * htemp = 0; while ((chainElem = (TChainElement*) next())) { //#ifndef XROOTD // f2 = TFile::Open("dcache:" + TString(chainElem->GetTitle())); //#else std::cout << "chainElem->GetTitle() " << chainElem->GetTitle() << std::endl; f2 = TFile::Open( TString(chainElem->GetTitle())); //#endif htemp = (TH1F*) f2->Get("Count"); h1->SetBinContent(1, h1->GetBinContent(1)+htemp->GetBinContent(1)); /* htemp = (TH1F*) f2->Get("CountWithPU"); h1->SetBinContent(2, h1->GetBinContent(2)+htemp->GetBinContent(1)); htemp = (TH1F*) f2->Get("CountWithPUP"); h1->SetBinContent(3, h1->GetBinContent(3)+htemp->GetBinContent(1)); htemp = (TH1F*) f2->Get("CountWithPUM"); h1->SetBinContent(4, h1->GetBinContent(4)+htemp->GetBinContent(1)); htemp = (TH1F*) f2->Get("CountWithMCProd"); h1->SetBinContent(5, h1->GetBinContent(5)+htemp->GetBinContent(1)); htemp = (TH1F*) f2->Get("CountWithPUMCProd"); h1->SetBinContent(6, h1->GetBinContent(6)+htemp->GetBinContent(1)); htemp = (TH1F*) f2->Get("countWithSignalQCDcorrections"); h1->SetBinContent(7, h1->GetBinContent(7)+htemp->GetBinContent(1)); */ std::clog << fname << ": skimmed from " << chainElem->GetTitle() << std::endl; } // LHE Count TH1D * h2 = new TH1D("LHECount", ";LHE Counts", 16, 0, 16); TString process_lhe = fname; if (process_lhe.BeginsWith("WJets")) process_lhe = "WJets"; else if (process_lhe.BeginsWith("ZJets")) process_lhe = "ZJets"; else process_lhe = ""; const std::vector<std::string>& lhecuts = GetLHECuts(process_lhe.Data()); for (unsigned int i=0; i < lhecuts.size(); i++) { TCut cut2 = lhecuts.at(i).c_str(); h2->SetBinContent(i+1, chain->GetEntries(cut2)); } // Make output directory if it doesn't exist if (gSystem->AccessPathName(outdir)) gSystem->mkdir(outdir); TString outname = outdir + prefix + Form("%s.root", outputname.Data()); std::cout << "outname is " << outname << std::endl; TFile* f1 = TFile::Open(outname, "RECREATE"); TTree* t1 = (TTree*) chain->CopyTree(selection); std::clog << fname << ": skimmed from " << chain->GetEntriesFast() << " to " << t1->GetEntriesFast() << " entries." << std::endl; t1->Write(); h1->Write(); h2->Write(); f1->Close(); return; }
void //HTT_ET_X(bool scaled=true, bool log=true, float min=0.1, float max=-1., string inputfile="root/$HISTFILE", const char* directory="eleTau_$CATEGORY") HTT_ET_X(bool scaled=true, bool log=true, float min=0.1, float max=-1., TString datacard="htt_et_1_7TeV", string inputfile="root/$HISTFILE", const char* directory="eleTau_$CATEGORY") { // defining the common canvas, axes pad styles SetStyle(); gStyle->SetLineStyleString(11,"20 10"); // determine category tag const char* category = ""; const char* category_extra = ""; const char* category_extra2 = ""; if(std::string(directory) == std::string("eleTau_0jet_low" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_0jet_low" )){ category_extra = "0-jet low p_{T}^{#tau_{h}}"; } if(std::string(directory) == std::string("eleTau_0jet_medium" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_0jet_medium" )){ category_extra = "0-jet low p_{T}^{#tau_{h}}"; } if(std::string(directory) == std::string("eleTau_0jet_high" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_0jet_high" )){ category_extra = "0-jet high p_{T}^{#tau_{h}}"; } if(std::string(directory) == std::string("eleTau_1jet_medium" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_1jet_medium" )){ category_extra = "1-jet low p_{T}^{#tau_{h}}"; } if(std::string(directory) == std::string("eleTau_1jet_high_lowhiggs" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_1jet_high_lowhiggs" )){ category_extra= "1-jet high p_{T}^{#tau_{h}}"; } if(std::string(directory) == std::string("eleTau_1jet_high_mediumhiggs")){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_1jet_high_mediumhiggs")){ category_extra= "1-jet high p_{T}^{#tau_{h}}"; } if(std::string(directory) == std::string("eleTau_1jet_high_mediumhiggs")){ category_extra2= "boosted"; } if(std::string(directory) == std::string("eleTau_vbf" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_vbf" )){ category_extra = "VBF tag"; } if(std::string(directory) == std::string("eleTau_vbf_loose" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_vbf_loose" )){ category_extra = "Loose VBF tag"; } if(std::string(directory) == std::string("eleTau_vbf_tight" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_vbf_tight" )){ category_extra = "Tight VBF tag"; } if(std::string(directory) == std::string("eleTau_nobtag" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_nobtag" )){ category_extra = "no b-tag"; } if(std::string(directory) == std::string("eleTau_btag" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_btag" )){ category_extra = "b-tag"; } if(std::string(directory) == std::string("eleTau_nobtag_low" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_nobtag_low" )){ category_extra = "no b-tag"; } if(std::string(directory) == std::string("eleTau_nobtag_low" )){ category_extra2 = "low p_{T}^{#tau_{h}}"; } if(std::string(directory) == std::string("eleTau_nobtag_medium" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_nobtag_medium" )){ category_extra = "no b-tag"; } if(std::string(directory) == std::string("eleTau_nobtag_medium" )){ category_extra2 = "medium p_{T}^{#tau_{h}}"; } if(std::string(directory) == std::string("eleTau_nobtag_high" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_nobtag_high" )){ category_extra = "no b-tag"; } if(std::string(directory) == std::string("eleTau_nobtag_high" )){ category_extra2 = "high p_{T}^{#tau_{h}}"; } if(std::string(directory) == std::string("eleTau_btag_low" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_btag_low" )){ category_extra = "b-tag"; } if(std::string(directory) == std::string("eleTau_btag_low" )){ category_extra2 = "low p_{T}^{#tau_{h}}"; } if(std::string(directory) == std::string("eleTau_btag_high" )){ category = "e#tau_{h}"; } if(std::string(directory) == std::string("eleTau_btag_high" )){ category_extra = "b-tag"; } if(std::string(directory) == std::string("eleTau_btag_high" )){ category_extra2 = "high p_{T}^{#tau_{h}}"; } const char* dataset; #ifdef MSSM if(std::string(inputfile).find("7TeV")!=std::string::npos){dataset = "#scale[1.5]{CMS} h,H,A#rightarrow#tau#tau 4.9 fb^{-1} (7 TeV)";} if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "#scale[1.5]{CMS} h,H,A#rightarrow#tau#tau 19.7 fb^{-1} (8 TeV)";} #else if(std::string(inputfile).find("7TeV")!=std::string::npos){dataset = "CMS, 4.9 fb^{-1} at 7 TeV";} if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "CMS, 19.7 fb^{-1} at 8 TeV";} #endif TFile* input = new TFile(inputfile.c_str()); #ifdef MSSM TFile* input2 = new TFile((inputfile+"_$MA_$TANB").c_str()); #endif TH1F* Fakes = refill((TH1F*)input->Get(TString::Format("%s/QCD" , directory)), "QCD"); InitHist(Fakes, "", "", TColor::GetColor(250,202,255), 1001); TH1F* EWK0 = refill((TH1F*)input->Get(TString::Format("%s/VV" , directory)), "VV" ); InitHist(EWK0 , "", "", TColor::GetColor(222,90,106), 1001); TH1F* EWK1 = refill((TH1F*)input->Get(TString::Format("%s/W" , directory)), "W" ); InitHist(EWK1 , "", "", TColor::GetColor(222,90,106), 1001); #ifdef EXTRA_SAMPLES TH1F* EWK2 = refill((TH1F*)input->Get(TString::Format("%s/ZJ" , directory)), "ZJ" ); InitHist(EWK2 , "", "", TColor::GetColor(100,182,232), 1001); TH1F* EWK = refill((TH1F*)input->Get(TString::Format("%s/ZL" , directory)), "ZL" ); InitHist(EWK , "", "", TColor::GetColor(100,182,232), 1001); #else TH1F* EWK = refill((TH1F*)input->Get(TString::Format("%s/ZLL" , directory)), "ZLL"); InitHist(EWK , "", "", TColor::GetColor(100,182,232), 1001); #endif TH1F* ttbar = refill((TH1F*)input->Get(TString::Format("%s/TT" , directory)), "TT" ); InitHist(ttbar, "", "", TColor::GetColor(155,152,204), 1001); TH1F* Ztt = refill((TH1F*)input->Get(TString::Format("%s/ZTT" , directory)), "ZTT"); InitHist(Ztt , "", "", TColor::GetColor(248,206,104), 1001); #ifdef MSSM TH1F* ggH = refill((TH1F*)input2->Get(TString::Format("%s/ggH$MA" , directory)), "ggH"); InitSignal(ggH); ggH->Scale($TANB); TH1F* bbH = refill((TH1F*)input2->Get(TString::Format("%s/bbH$MA" , directory)), "bbH"); InitSignal(bbH); bbH->Scale($TANB); TH1F* ggH_SM125= refill((TH1F*)input->Get(TString::Format("%s/ggH_SM125" , directory)), "ggH_SM125"); InitHist(ggH_SM125, "", "", kGreen+2, 1001); TH1F* qqH_SM125= refill((TH1F*)input->Get(TString::Format("%s/qqH_SM125" , directory)), "qqH_SM125"); InitHist(qqH_SM125, "", "", kGreen+2, 1001); TH1F* VH_SM125 = refill((TH1F*)input->Get(TString::Format("%s/VH_SM125" , directory)), "VH_SM125" ); InitHist(VH_SM125, "", "", kGreen+2, 1001); #else #ifndef DROP_SIGNAL TH1F* ggH = refill((TH1F*)input->Get(TString::Format("%s/ggH125" , directory)), "ggH"); InitSignal(ggH); ggH->Scale(SIGNAL_SCALE); TH1F* qqH = refill((TH1F*)input->Get(TString::Format("%s/qqH125" , directory)), "qqH"); InitSignal(qqH); qqH->Scale(SIGNAL_SCALE); TH1F* VH = refill((TH1F*)input->Get(TString::Format("%s/VH125" , directory)), "VH" ); InitSignal(VH ); VH ->Scale(SIGNAL_SCALE); #endif #endif #ifdef ASIMOV TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs_asimov", directory)), "data", true); #else TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs", directory)), "data", true); #endif InitHist(data, "#bf{m_{#tau#tau} [GeV]}", "#bf{dN/dm_{#tau#tau} [1/GeV]}"); InitData(data); TH1F* ref=(TH1F*)Fakes->Clone("ref"); ref->Add(EWK0 ); ref->Add(EWK1 ); #ifdef EXTRA_SAMPLES ref->Add(EWK2 ); #endif ref->Add(EWK ); ref->Add(ttbar); ref->Add(Ztt ); double unscaled[7]; unscaled[0] = Fakes->Integral(); unscaled[1] = EWK ->Integral(); unscaled[1]+= EWK0 ->Integral(); unscaled[1]+= EWK1 ->Integral(); #ifdef EXTRA_SAMPLES unscaled[1]+= EWK2 ->Integral(); #endif unscaled[2] = ttbar->Integral(); unscaled[3] = Ztt ->Integral(); #ifdef MSSM unscaled[4] = ggH ->Integral(); unscaled[5] = bbH ->Integral(); unscaled[6] = 0; #else #ifndef DROP_SIGNAL unscaled[4] = ggH ->Integral(); unscaled[5] = qqH ->Integral(); unscaled[6] = VH ->Integral(); #endif #endif if(scaled){ /* Fakes = refill(shape_histos(Fakes, datacard, "QCD"), "QCD"); EWK0 = refill(shape_histos(EWK0, datacard, "VV"), "VV"); EWK1 = refill(shape_histos(EWK1, datacard, "W"), "W"); #ifdef EXTRA_SAMPLES EWK2 = refill(shape_histos(EWK2, datacard, "ZJ"), "ZJ"); EWK = refill(shape_histos(EWK, datacard, "ZL"), "ZL"); #else // EWK = refill(shape_histos(EWK, datacard, "ZLL"), "ZLL"); #endif ttbar = refill(shape_histos(ttbar, datacard, "TT"), "TT"); Ztt = refill(shape_histos(Ztt, datacard, "ZTT"), "ZTT"); #ifdef MSSM ggH = refill(shape_histos(ggH, datacard, "ggH$MA"), "ggH$MA"); bbH = refill(shape_histos(bbH, datacard, "bbH$MA"), "bbH$MA"); #else #ifndef DROP_SIGNAL ggH = refill(shape_histos(ggH, datacard, "ggH"), "ggH"); qqH = refill(shape_histos(qqH, datacard, "qqH"), "qqH"); VH = refill(shape_histos(VH, datacard, "VH"), "VH"); #endif #endif */ rescale(Fakes, 7); rescale(EWK0 , 6); rescale(EWK1 , 3); #ifdef EXTRA_SAMPLES rescale(EWK2 , 4); rescale(EWK , 5); #else rescale(EWK , 4); #endif rescale(ttbar, 2); rescale(Ztt , 1); #ifdef MSSM rescale(ggH , 8); rescale(bbH , 9); #else #ifndef DROP_SIGNAL rescale(ggH , 8); rescale(qqH , 9); rescale(VH ,10); #endif #endif } TH1F* scales[7]; scales[0] = new TH1F("scales-Fakes", "", 7, 0, 7); scales[0]->SetBinContent(1, unscaled[0]>0 ? (Fakes->Integral()/unscaled[0]-1.) : 0.); scales[1] = new TH1F("scales-EWK" , "", 7, 0, 7); scales[1]->SetBinContent(2, unscaled[1]>0 ? ((EWK ->Integral() +EWK0 ->Integral() +EWK1 ->Integral() #ifdef EXTRA_SAMPLES +EWK2 ->Integral() #endif )/unscaled[1]-1.) : 0.); scales[2] = new TH1F("scales-ttbar", "", 7, 0, 7); scales[2]->SetBinContent(3, unscaled[2]>0 ? (ttbar->Integral()/unscaled[2]-1.) : 0.); scales[3] = new TH1F("scales-Ztt" , "", 7, 0, 7); scales[3]->SetBinContent(4, unscaled[3]>0 ? (Ztt ->Integral()/unscaled[3]-1.) : 0.); #ifdef MSSM scales[4] = new TH1F("scales-ggH" , "", 7, 0, 7); scales[4]->SetBinContent(5, unscaled[4]>0 ? (ggH ->Integral()/unscaled[4]-1.) : 0.); scales[5] = new TH1F("scales-bbH" , "", 7, 0, 7); scales[5]->SetBinContent(6, unscaled[5]>0 ? (bbH ->Integral()/unscaled[5]-1.) : 0.); scales[6] = new TH1F("scales-NONE" , "", 7, 0, 7); scales[6]->SetBinContent(7, 0.); #else #ifndef DROP_SIGNAL scales[4] = new TH1F("scales-ggH" , "", 7, 0, 7); scales[4]->SetBinContent(5, unscaled[4]>0 ? (ggH ->Integral()/unscaled[4]-1.) : 0.); scales[5] = new TH1F("scales-qqH" , "", 7, 0, 7); scales[5]->SetBinContent(6, unscaled[5]>0 ? (qqH ->Integral()/unscaled[5]-1.) : 0.); scales[6] = new TH1F("scales-VH" , "", 7, 0, 7); scales[6]->SetBinContent(7, unscaled[6]>0 ? (VH ->Integral()/unscaled[6]-1.) : 0.); #endif #endif #ifdef MSSM qqH_SM125->Add(ggH_SM125); VH_SM125->Add(qqH_SM125); Fakes->Add(VH_SM125); #endif EWK0 ->Add(Fakes); EWK1 ->Add(EWK0 ); #ifdef EXTRA_SAMPLES EWK2 ->Add(EWK1 ); EWK ->Add(EWK2 ); #else EWK ->Add(EWK1 ); #endif ttbar->Add(EWK ); Ztt ->Add(ttbar); #ifdef MSSM ggH ->Add(bbH); #endif if(log){ #ifdef MSSM //ggH ->Add(bbH); #else #ifndef DROP_SIGNAL qqH ->Add(VH ); ggH ->Add(qqH); #endif #endif } else{ #ifdef MSSM bbH ->Add(Ztt); ggH ->Add(bbH); #else #ifndef DROP_SIGNAL VH ->Add(Ztt); qqH ->Add(VH ); ggH ->Add(qqH); #endif #endif } /* Mass plot before and after fit */ TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600); canv->cd(); if(log){ canv->SetLogy(1); } #if defined MSSM if(!log){ data->GetXaxis()->SetRange(0, data->FindBin(345)); } else{ data->GetXaxis()->SetRange(0, data->FindBin(UPPER_EDGE)); }; #else data->GetXaxis()->SetRange(0, data->FindBin(345)); #endif data->SetNdivisions(505); data->SetMinimum(min); #ifndef DROP_SIGNAL data->SetMaximum(max>0 ? max : std::max(std::max(maximum(data, log), maximum(Ztt, log)), maximum(ggH, log))); #else data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(Ztt, log))); #endif data->Draw("e"); TH1F* errorBand = (TH1F*)Ztt ->Clone("errorBand"); errorBand ->SetMarkerSize(0); errorBand ->SetFillColor(13); errorBand ->SetFillStyle(3013); errorBand ->SetLineWidth(1); for(int idx=0; idx<errorBand->GetNbinsX(); ++idx){ if(errorBand->GetBinContent(idx)>0){ std::cout << "Uncertainties on summed background samples: " << errorBand->GetBinError(idx)/errorBand->GetBinContent(idx) << std::endl; break; } } if(log){ Ztt ->Draw("histsame"); ttbar->Draw("histsame"); EWK ->Draw("histsame"); EWK1 ->Draw("histsame"); Fakes->Draw("histsame"); #ifdef MSSM VH_SM125->Draw("histsame"); #endif $DRAW_ERROR #ifndef DROP_SIGNAL ggH ->Draw("histsame"); #endif } else{ #ifndef DROP_SIGNAL ggH ->Draw("histsame"); #endif Ztt ->Draw("histsame"); ttbar->Draw("histsame"); EWK ->Draw("histsame"); EWK1 ->Draw("histsame"); Fakes->Draw("histsame"); #ifdef MSSM VH_SM125->Draw("histsame"); #endif $DRAW_ERROR } data->Draw("esame"); canv->RedrawAxis(); //CMSPrelim(dataset, "#tau_{e}#tau_{h}", 0.17, 0.835); CMSPrelim(dataset, "", 0.16, 0.835); #if defined MSSM TPaveText* chan = new TPaveText(0.20, 0.74+0.061, 0.32, 0.74+0.161, "tlbrNDC"); if (category_extra2!="") chan = new TPaveText(0.20, 0.69+0.061, 0.32, 0.74+0.161, "tlbrNDC"); #else TPaveText* chan = new TPaveText(0.52, 0.35, 0.91, 0.55, "tlbrNDC"); #endif chan->SetBorderSize( 0 ); chan->SetFillStyle( 0 ); chan->SetTextAlign( 12 ); chan->SetTextSize ( 0.05 ); chan->SetTextColor( 1 ); chan->SetTextFont ( 62 ); chan->AddText(category); chan->AddText(category_extra); #if defined MSSM if (category_extra2!="") chan->AddText(category_extra2); #else chan->AddText(category_extra2); #endif chan->Draw(); /* TPaveText* cat = new TPaveText(0.20, 0.71+0.061, 0.32, 0.71+0.161, "NDC"); cat->SetBorderSize( 0 ); cat->SetFillStyle( 0 ); cat->SetTextAlign( 12 ); cat->SetTextSize ( 0.05 ); cat->SetTextColor( 1 ); cat->SetTextFont ( 62 ); cat->AddText(category_extra); cat->Draw(); TPaveText* cat2 = new TPaveText(0.20, 0.66+0.061, 0.32, 0.66+0.161, "NDC"); cat2->SetBorderSize( 0 ); cat2->SetFillStyle( 0 ); cat2->SetTextAlign( 12 ); cat2->SetTextSize ( 0.05 ); cat2->SetTextColor( 1 ); cat2->SetTextFont ( 62 ); cat2->AddText(category_extra2); cat2->Draw(); */ #ifdef MSSM TPaveText* massA = new TPaveText(0.53, 0.44+0.061, 0.95, 0.44+0.151, "NDC"); massA->SetBorderSize( 0 ); massA->SetFillStyle( 0 ); massA->SetTextAlign( 12 ); massA->SetTextSize ( 0.03 ); massA->SetTextColor( 1 ); massA->SetTextFont ( 62 ); massA->AddText("MSSM m^{h}_{mod+} scenario"); massA->AddText("m_{A}=$MA GeV, tan#beta=$TANB"); massA->Draw(); #endif #ifdef MSSM TLegend* leg = new TLegend(0.53, 0.60, 0.95, 0.90); SetLegendStyle(leg); leg->AddEntry(ggH , "h,A,H#rightarrow#tau#tau" , "L" ); #else TLegend* leg = new TLegend(0.52, 0.58, 0.92, 0.89); SetLegendStyle(leg); #ifndef DROP_SIGNAL if(SIGNAL_SCALE!=1){ leg->AddEntry(ggH , TString::Format("%.0f#timesH(125 GeV)#rightarrow#tau#tau", SIGNAL_SCALE) , "L" ); } else{ leg->AddEntry(ggH , "SM H(125 GeV)#rightarrow#tau#tau" , "L" ); } #endif #endif #ifdef ASIMOV leg->AddEntry(data , "sum(bkg) + H(125)" , "LP"); #else leg->AddEntry(data , "Observed" , "LP"); #endif leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" ); leg->AddEntry(EWK , "Z#rightarrow ee" , "F" ); leg->AddEntry(EWK1 , "W+jets" , "F" ); leg->AddEntry(ttbar, "t#bar{t}" , "F" ); leg->AddEntry(Fakes, "QCD" , "F" ); #ifdef MSSM leg->AddEntry(VH_SM125, "SM H(125 GeV) #rightarrow #tau#tau", "F" ); #endif $ERROR_LEGEND leg->Draw(); /* Ratio Data over MC */ TCanvas *canv0 = MakeCanvas("canv0", "histograms", 600, 400); canv0->SetGridx(); canv0->SetGridy(); canv0->cd(); TH1F* model = (TH1F*)Ztt ->Clone("model"); TH1F* test1 = (TH1F*)data->Clone("test1"); for(int ibin=0; ibin<test1->GetNbinsX(); ++ibin){ //the small value in case of 0 entries in the model is added to prevent the chis2 test from failing model->SetBinContent(ibin+1, model->GetBinContent(ibin+1)>0 ? model->GetBinContent(ibin+1)*model->GetBinWidth(ibin+1) : 0.01); model->SetBinError (ibin+1, CONVERVATIVE_CHI2 ? 0. : model->GetBinError (ibin+1)*model->GetBinWidth(ibin+1)); test1->SetBinContent(ibin+1, test1->GetBinContent(ibin+1)*test1->GetBinWidth(ibin+1)); test1->SetBinError (ibin+1, test1->GetBinError (ibin+1)*test1->GetBinWidth(ibin+1)); } double chi2prob = test1->Chi2Test (model,"PUW"); std::cout << "chi2prob:" << chi2prob << std::endl; double chi2ndof = test1->Chi2Test (model,"CHI2/NDFUW"); std::cout << "chi2ndf :" << chi2ndof << std::endl; double ksprob = test1->KolmogorovTest(model); std::cout << "ksprob :" << ksprob << std::endl; double ksprobpe = test1->KolmogorovTest(model,"DX"); std::cout << "ksprobpe:" << ksprobpe << std::endl; std::vector<double> edges; TH1F* zero = (TH1F*)ref->Clone("zero"); zero->Clear(); TH1F* rat1 = (TH1F*)data->Clone("rat1"); for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){ rat1->SetBinContent(ibin+1, Ztt->GetBinContent(ibin+1)>0 ? data->GetBinContent(ibin+1)/Ztt->GetBinContent(ibin+1) : 0); rat1->SetBinError (ibin+1, Ztt->GetBinContent(ibin+1)>0 ? data->GetBinError (ibin+1)/Ztt->GetBinContent(ibin+1) : 0); zero->SetBinContent(ibin+1, 0.); zero->SetBinError (ibin+1, Ztt->GetBinContent(ibin+1)>0 ? Ztt ->GetBinError (ibin+1)/Ztt->GetBinContent(ibin+1) : 0); } for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){ if(rat1->GetBinContent(ibin+1)>0){ edges.push_back(TMath::Abs(rat1->GetBinContent(ibin+1)-1.)+TMath::Abs(rat1->GetBinError(ibin+1))); // catch cases of 0 bins, which would lead to 0-alpha*0-1 rat1->SetBinContent(ibin+1, rat1->GetBinContent(ibin+1)-1.); } } float range = 0.1; std::sort(edges.begin(), edges.end()); if (edges[edges.size()-2]>0.1) { range = 0.2; } if (edges[edges.size()-2]>0.2) { range = 0.5; } if (edges[edges.size()-2]>0.5) { range = 1.0; } if (edges[edges.size()-2]>1.0) { range = 1.5; } if (edges[edges.size()-2]>1.5) { range = 2.0; } rat1->SetLineColor(kBlack); rat1->SetFillColor(kGray ); rat1->SetMaximum(+range); rat1->SetMinimum(-range); rat1->GetYaxis()->CenterTitle(); rat1->GetYaxis()->SetTitle("#bf{Data/MC-1}"); rat1->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}"); rat1->Draw(); zero->SetFillStyle( 3013); zero->SetFillColor(kBlack); zero->SetLineColor(kBlack); zero->SetMarkerSize(0.1); zero->Draw("e2histsame"); canv0->RedrawAxis(); TPaveText* stat1 = new TPaveText(0.20, 0.76+0.061, 0.32, 0.76+0.161, "NDC"); stat1->SetBorderSize( 0 ); stat1->SetFillStyle( 0 ); stat1->SetTextAlign( 12 ); stat1->SetTextSize ( 0.05 ); stat1->SetTextColor( 1 ); stat1->SetTextFont ( 62 ); stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f", chi2ndof, chi2prob)); //stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f, P(KS)=%.3f", chi2ndof, chi2prob, ksprob)); stat1->Draw(); /* Ratio After fit over Prefit */ TCanvas *canv1 = MakeCanvas("canv1", "histograms", 600, 400); canv1->SetGridx(); canv1->SetGridy(); canv1->cd(); edges.clear(); TH1F* rat2 = (TH1F*) Ztt->Clone("rat2"); for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){ rat2->SetBinContent(ibin+1, ref->GetBinContent(ibin+1)>0 ? Ztt->GetBinContent(ibin+1)/ref->GetBinContent(ibin+1) : 0); rat2->SetBinError (ibin+1, ref->GetBinContent(ibin+1)>0 ? Ztt->GetBinError (ibin+1)/ref->GetBinContent(ibin+1) : 0); } for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){ if(rat2->GetBinContent(ibin+1)>0){ edges.push_back(TMath::Abs(rat2->GetBinContent(ibin+1)-1.)+TMath::Abs(rat2->GetBinError(ibin+1))); // catch cases of 0 bins, which would lead to 0-alpha*0-1 rat2 ->SetBinContent(ibin+1, rat2->GetBinContent(ibin+1)-1.); } } range = 0.1; std::sort(edges.begin(), edges.end()); if (edges[edges.size()-2]>0.1) { range = 0.2; } if (edges[edges.size()-2]>0.2) { range = 0.5; } if (edges[edges.size()-2]>0.5) { range = 1.0; } if (edges[edges.size()-2]>1.0) { range = 1.5; } if (edges[edges.size()-2]>1.5) { range = 2.0; } #if defined MSSM if(!log){ rat2->GetXaxis()->SetRange(0, rat2->FindBin(345)); } else{ rat2->GetXaxis()->SetRange(0, rat2->FindBin(UPPER_EDGE)); }; #else rat2->GetXaxis()->SetRange(0, rat2->FindBin(345)); #endif rat2->SetNdivisions(505); rat2->SetLineColor(kRed+ 3); rat2->SetMarkerColor(kRed+3); rat2->SetMarkerSize(1.1); rat2->SetMaximum(+range); rat2->SetMinimum(-range); rat2->GetYaxis()->SetTitle("#bf{Postfit/Prefit-1}"); rat2->GetYaxis()->CenterTitle(); rat2->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}"); rat2->Draw(); zero->SetFillStyle( 3013); zero->SetFillColor(kBlack); zero->SetLineColor(kBlack); zero->Draw("e2histsame"); canv1->RedrawAxis(); /* Relative shift per sample */ TCanvas *canv2 = MakeCanvas("canv2", "histograms", 600, 400); canv2->SetGridx(); canv2->SetGridy(); canv2->cd(); InitHist (scales[0], "", "", TColor::GetColor(250,202,255), 1001); InitHist (scales[1], "", "", TColor::GetColor(222,90,106), 1001); InitHist (scales[2], "", "", TColor::GetColor(155,152,204), 1001); InitHist (scales[3], "", "", TColor::GetColor(248,206,104), 1001); #ifndef DROP_SIGNAL InitSignal(scales[4]); InitSignal(scales[5]); InitSignal(scales[6]); #endif scales[0]->Draw(); scales[0]->GetXaxis()->SetBinLabel(1, "#bf{Fakes}"); scales[0]->GetXaxis()->SetBinLabel(2, "#bf{EWK}" ); scales[0]->GetXaxis()->SetBinLabel(3, "#bf{ttbar}"); scales[0]->GetXaxis()->SetBinLabel(4, "#bf{Ztt}" ); #ifdef MSSM scales[0]->GetXaxis()->SetBinLabel(5, "#bf{ggH}" ); scales[0]->GetXaxis()->SetBinLabel(6, "#bf{bbH}" ); scales[0]->GetXaxis()->SetBinLabel(7, "NONE" ); #else scales[0]->GetXaxis()->SetBinLabel(5, "#bf{ggH}" ); scales[0]->GetXaxis()->SetBinLabel(6, "#bf{qqH}" ); scales[0]->GetXaxis()->SetBinLabel(7, "#bf{VH}" ); #endif scales[0]->SetMaximum(+0.5); scales[0]->SetMinimum(-0.5); scales[0]->GetYaxis()->CenterTitle(); scales[0]->GetYaxis()->SetTitle("#bf{Postfit/Prefit-1}"); scales[1]->Draw("same"); scales[2]->Draw("same"); scales[3]->Draw("same"); #ifndef DROP_SIGNAL scales[4]->Draw("same"); scales[5]->Draw("same"); scales[6]->Draw("same"); #endif TH1F* zero_samples = (TH1F*)scales[0]->Clone("zero_samples"); zero_samples->Clear(); zero_samples->SetBinContent(1,0.); zero_samples->Draw("same"); canv2->RedrawAxis(); /* prepare output */ bool isSevenTeV = std::string(inputfile).find("7TeV")!=std::string::npos; canv ->Print(TString::Format("%s_%sfit_%s_%s.png" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); canv ->Print(TString::Format("%s_%sfit_%s_%s.pdf" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); canv ->Print(TString::Format("%s_%sfit_%s_%s.eps" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); if(!log || FULLPLOTS) { canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); } if((!log && scaled) || FULLPLOTS) { canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN")); } TFile* output = new TFile(TString::Format("%s_%sfit_%s_%s.root", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"), "update"); output->cd(); data ->Write("data_obs"); Fakes->Write("Fakes" ); EWK ->Write("Zee" ); EWK1 ->Write("EWK" ); //EWK ->Write("EWK" ); EWK1 ->Write("EWK1" ); ttbar->Write("ttbar" ); Ztt ->Write("Ztt" ); #ifdef MSSM ggH ->Write("ggH" ); bbH ->Write("bbH" ); ggH_SM125->Write("ggH_SM125"); qqH_SM125->Write("qqH_SM125"); VH_SM125 ->Write("VH_SM125"); #else #ifndef DROP_SIGNAL ggH ->Write("ggH" ); qqH ->Write("qqH" ); VH ->Write("VH" ); #endif #endif if(errorBand){ errorBand->Write("errorBand"); } output->Close(); delete errorBand; delete model; delete test1; delete zero; delete rat1; delete rat2; delete zero_samples; delete ref; }
void compareSherpaMadgraph(std::string sherpafile, std::string madgraphfile, std::string var, float xmin=-9999.0, float xmax=-9999.0, bool logScale=false, std::string output="test") { setTDRStyle(); gStyle->SetOptStat(0); TH1F* hsherpa; TH1F* hmadgraph; char tempName[300]; // first get the histogram files TFile *fsherpa = TFile::Open(sherpafile.data()); TFile *fmadgraph = TFile::Open(madgraphfile.data()); hsherpa = (TH1F*)(fsherpa->Get(var.data())); hmadgraph = (TH1F*)(fmadgraph->Get(var.data())); TH1D* hscale =(TH1D*) hsherpa->Clone("hscale"); hscale->SetYTitle("SHERPA/MADGRAPH"); int nREBIN=2; if(var.find("pt")!= std::string::npos) nREBIN=4; hsherpa->GetXaxis()->SetNdivisions(5); hsherpa->GetYaxis()->SetDecimals(); hsherpa->Rebin(nREBIN); hmadgraph->GetXaxis()->SetNdivisions(5); hmadgraph->GetYaxis()->SetDecimals(); hmadgraph->Rebin(nREBIN); hscale->GetXaxis()->SetNdivisions(5); hscale->GetYaxis()->SetDecimals(); hscale->Rebin(nREBIN); hsherpa->SetLineColor(2); hsherpa->SetMarkerColor(2); hsherpa->SetMarkerSize(1); hsherpa->SetMarkerStyle(24); hmadgraph->SetLineColor(4); hmadgraph->SetMarkerColor(4); hmadgraph->SetMarkerSize(1); hmadgraph->SetMarkerStyle(21); // if normalizing to the same area, set the scale int binLo = -1; int binHi = -1; int nbins = hsherpa->GetNbinsX(); if(xmin>-9999.0 && xmax>-9999.0) { binLo = hsherpa->FindBin(xmin); binHi = hsherpa->FindBin(xmax)-1; } else { binLo = 1; binHi = nbins; xmin = hsherpa->GetBinLowEdge(1); xmax = hsherpa->GetBinLowEdge(nbins+1); } // float scale_mc = (float)hsherpa->Integral(binLo,binHi)/(float)hmadgraph->Integral(binLo,binHi); // cout << "binLo = " << binLo << ", binHi = " << binHi << endl; // cout << "xmin = " << xmin << "xmax = " << xmax << endl; // hmadgraph->Sumw2(); // hmadgraph->Scale(scale_mc); float scale_sherpa = 1000.0*4.890*3048.0/4.71644910071102437e+06; float scale_madgraph = 1000.0*4.890*3048.0/3.59644320000000000e+07; hsherpa->Sumw2(); hsherpa->Scale(scale_sherpa); hmadgraph->Sumw2(); hmadgraph->Scale(scale_madgraph); cout << "hmadgraph integral = " << hmadgraph->Integral() << endl; cout << "hsherpa integral = " << hsherpa->Integral() << endl;; // get the ratio double chi2 = 0; int realbin = 0; for(int i=1; i<= nbins; i++) { double nmc=hmadgraph->GetBinContent(i); double ndata=hsherpa->GetBinContent(i); double nmcerr=hmadgraph->GetBinError(i); double ndataerr=hsherpa->GetBinError(i); if(nmc<0 || ndata<0)continue; if(nmcerr==0 && ndataerr==0)continue; if(nmc==0 && ndata==0)continue; double chi2ndef = (nmc-ndata)*(nmc-ndata)/ ( nmcerr*nmcerr+ ndataerr*ndataerr); chi2 += chi2ndef; realbin++; cout << "Bin " << i << " : " << ndata << ", " << nmc; cout << " " << chi2ndef << endl; // now calculate the ratio if(nmc==0 || nmcerr==0 || ndata==0 || ndataerr==0)continue; cout << "Bin " << i << " ratio = " << ndata/nmc << endl; hscale->SetBinContent(i,ndata/nmc); double err = 0; err= (ndata/nmc)*sqrt(pow(nmcerr/nmc,2)+pow(ndataerr/ndata,2)); hscale->SetBinError(i,err); } hsherpa->GetXaxis()->SetRangeUser(xmin,xmax); hmadgraph->GetXaxis()->SetRangeUser(xmin,xmax); hscale->GetXaxis()->SetRangeUser(xmin,xmax); TCanvas* c1 = new TCanvas("c1","",700,1000); c1->Divide(1,2,0.01,0); c1->cd(1); if(logScale) gPad->SetLogy(1); gPad->SetTopMargin(0.01); gPad->SetBottomMargin(0); gPad->SetRightMargin(0.04); float max_data = hsherpa->GetBinError(hsherpa->GetMaximumBin()) + hsherpa->GetMaximum(); float max_mc = hmadgraph->GetBinError(hmadgraph->GetMaximumBin()) + hmadgraph->GetMaximum(); if(max_data > max_mc) { hsherpa->Draw("e"); hmadgraph->Draw("hesame"); } else { hmadgraph->Draw("he"); hsherpa->Draw("esame"); } float x1NDC = 0.691; float y1NDC = 0.757; float x2NDC = 0.894; float y2NDC = 0.973; TLegend* leg = new TLegend(x1NDC,y1NDC,x2NDC,y2NDC); leg->SetFillColor(0); leg->SetFillStyle(0); leg->SetTextSize(0.04); leg->SetBorderSize(0); leg->AddEntry(hsherpa, "SHERPA"); leg->AddEntry(hmadgraph, "MADGRAPH"); leg->Draw("same"); c1->cd(2); gStyle->SetStatW (0.3); gStyle->SetStatH (0.3); gStyle->SetStatX (0.879447); gStyle->SetStatY (0.939033); gStyle->SetStatFontSize(0.05); gStyle->SetStatBorderSize(0); gPad->SetRightMargin(0.04); gPad->SetTopMargin(0); gPad->SetBottomMargin(0.2); gPad->SetTickx(); gStyle->SetOptFit(1); hscale->SetTitle(""); hscale->SetMaximum(3.0); hscale->SetMinimum(-0.5); hscale->SetTitleOffset(1.2,"Y"); hscale->Draw("e1"); TF1* fline = new TF1("fline","pol1"); TLine* l2 = new TLine(xmin,1.,xmax,1.); l2->SetLineColor(4); l2->SetLineStyle(3); fline->SetLineWidth(3); fline->SetLineColor(6); fline->SetNpx(2500); hscale->Fit("fline","",""); l2->Draw("same"); string dirName = "compareSherpaMadgraph"; gSystem->mkdir(dirName.data()); std::string filename; std::string psname = dirName + "/" + var; if(output !="test") psname = dirName+ "/" + output; else psname = dirName+ "/" + var; filename = psname + ".eps"; c1->Print(filename.data()); filename = psname + ".gif"; c1->Print(filename.data()); filename = psname + ".pdf"; c1->Print(filename.data()); // c1->Close(); }
void plotRatioDoubleratio(TString varname_="", TString vartex_="") { gStyle->SetTextSize(0.05); gStyle->SetTextFont(42); gStyle->SetPadRightMargin(0.05); gStyle->SetPadLeftMargin(0.15); gStyle->SetPadTopMargin(0.1); gStyle->SetPadBottomMargin(0.145); gStyle->SetTitleX(.0f); gStyle->SetOptStat(0); gStyle->SetMarkerStyle(20); gStyle->SetMarkerSize(0.8); varname=varname_; vartex=vartex_; TFile* infPP = new TFile(Form("outfDoubleratio/fPP_%s_DoubleRatio.root",varname.Data())); TH1D* hPP = (TH1D*)infPP->Get("hDoubleRatio"); hPP->SetName(Form("hPP_%.0f",varname.Data())); TFile* infPbPb = new TFile(Form("outfDoubleratio/fPbPb_%s_DoubleRatio.root",varname.Data())); TH1D* hPbPb = (TH1D*)infPbPb->Get("hDoubleRatio"); hPbPb->SetName(Form("hPbPb_%.0f",varname.Data())); TFile* infPPMB = new TFile(Form("outfDoubleratio/fPPMB_%s_DoubleRatio.root",varname.Data())); TH1D* hPPMB = (TH1D*)infPPMB->Get("hDoubleRatio"); hPPMB->SetName(Form("hPPMB_%.0f",varname.Data())); TFile* infPbPbMB = new TFile(Form("outfDoubleratio/fPbPbMB_%s_DoubleRatio.root",varname.Data())); TH1D* hPbPbMB = (TH1D*)infPbPbMB->Get("hDoubleRatio"); hPbPbMB->SetName(Form("hPbPbMB_%.0f",varname.Data())); TH1F* hRatio = (TH1F*)hPbPb->Clone("hRatio"); hRatio->Divide(hPP); TH1F* hRatioMB = (TH1F*)hPbPbMB->Clone("hRatioMB"); hRatioMB->Divide(hPPMB); Int_t varbins = hRatio->GetNbinsX(); Float_t varstep = hRatio->GetBinWidth(1); Float_t varmin = hRatio->GetBinCenter(1)-0.5*varstep; Float_t varmax = hRatio->GetBinCenter(varbins)-0.5*varstep; Float_t aRatio[varbins],aRatioErr[varbins]; Float_t aRatioMB[varbins],aRatioMBErr[varbins]; Float_t aX[varbins],aZero[varbins]; for(int i=0;i<varbins;i++) { aX[i] = hRatio->GetBinCenter(i+1)-0.5*varstep; aZero[i] = 0; aRatio[i] = hRatio->GetBinContent(i+1); aRatioErr[i] = hRatio->GetBinError(i+1); aRatioMB[i] = hRatioMB->GetBinContent(i+1); aRatioMBErr[i] = hRatioMB->GetBinError(i+1); } TGraphErrors* gRatio = new TGraphErrors(varbins,aX,aRatio,aZero,aRatioErr); TH2F* hemptyRatio = new TH2F("hemptyRatio","",20,varmin-0.5*varstep,varmax+0.5*varstep,10.,0.7,1.3); hemptyRatio->GetXaxis()->SetTitle(Form("%s",vartex.Data())); hemptyRatio->GetYaxis()->SetTitle("DoubleRatio^{PbPb} / DoubleRatio^{PP}"); hemptyRatio->GetXaxis()->SetTitleOffset(1.); hemptyRatio->GetYaxis()->SetTitleOffset(.9); hemptyRatio->GetXaxis()->SetTitleSize(0.045); hemptyRatio->GetYaxis()->SetTitleSize(0.045); hemptyRatio->GetXaxis()->SetTitleFont(42); hemptyRatio->GetYaxis()->SetTitleFont(42); hemptyRatio->GetXaxis()->SetLabelFont(42); hemptyRatio->GetYaxis()->SetLabelFont(42); hemptyRatio->GetXaxis()->SetLabelSize(0.04); hemptyRatio->GetYaxis()->SetLabelSize(0.04); TCanvas* cRatio = new TCanvas("cRatio","",600,600); hemptyRatio->Draw(); gRatio->Draw("psame"); cRatio->SaveAs(Form("plotRatios/cRatio_%s.pdf",varname.Data())); TGraphErrors* gRatioMB = new TGraphErrors(varbins,aX,aRatioMB,aZero,aRatioMBErr); TH2F* hemptyRatioMB = new TH2F("hemptyRatioMB","",20,varmin-0.5*varstep,varmax+0.5*varstep,10.,0.7,1.3); hemptyRatioMB->GetXaxis()->SetTitle(Form("%s",vartex.Data())); hemptyRatioMB->GetYaxis()->SetTitle("DoubleRatio^{PbPb} / DoubleRatio^{PP}"); hemptyRatioMB->GetXaxis()->SetTitleOffset(1.); hemptyRatioMB->GetYaxis()->SetTitleOffset(.9); hemptyRatioMB->GetXaxis()->SetTitleSize(0.045); hemptyRatioMB->GetYaxis()->SetTitleSize(0.045); hemptyRatioMB->GetXaxis()->SetTitleFont(42); hemptyRatioMB->GetYaxis()->SetTitleFont(42); hemptyRatioMB->GetXaxis()->SetLabelFont(42); hemptyRatioMB->GetYaxis()->SetLabelFont(42); hemptyRatioMB->GetXaxis()->SetLabelSize(0.04); hemptyRatioMB->GetYaxis()->SetLabelSize(0.04); TCanvas* cRatioMB = new TCanvas("cRatioMB","",600,600); hemptyRatioMB->Draw(); gRatioMB->Draw("psame"); cRatioMB->SaveAs(Form("plotRatios/cRatioMB_%s.pdf",varname.Data())); }
//Compare the btag histo files histograms bin-by-bin void CompareBtagEffFiles( TString ind = "" , TString inf = "" ) { const int ngraph = 9; // # plots to compare const int nbins = 19; // # bins to compare in each plot const int taggedgraphs = 6; // # plots which are simple counts only TFile myFiled(ind); TFile myFilef(inf); if ( myFiled.IsZombie() || myFilef.IsZombie() ) { cout << "Files are zombies!" << endl; return; } string names_d[ngraph] = {"h_bjet","h_cjet","h_ljet","h_btag","h_ctag","h_ltag","h_btageff","h_ctageff","h_ltageff"}; string names_f[ngraph] = {"h_bjet","h_cjet","h_ljet","h_btag","h_ctag","h_ltag","h_btageff","h_ctageff","h_ltageff"}; double ptbins[18] = {20, 30, 40, 50, 60, 70, 80, 100, 120, 160, 210, 260, 320, 400, 500, 600, 800, 99999}; TH1D * histd; TH1F * histf; cout << endl << "Comparing histograms in the btag eff histo files bin-by-bin (inc under/over-flow). " << endl; cout << "-------------------------------------------------------------" << endl; for( int i = 0; i < ngraph; i++ ) { //This 'hack' absolutely needed. Don't ask... char hist_named[200], hist_namef[200]; sprintf(hist_named,"%s",names_d[i].c_str()); sprintf(hist_namef,"%s",names_f[i].c_str()); cout << endl << "Now processing " << names_d[i] << " and " << names_f[i] << " ... " << endl << endl; myFiled.cd(""); histd = (TH1D*) gDirectory->Get(hist_named); myFilef.cd(""); histf = (TH1F*) gDirectory->Get(hist_namef); if (histd->IsZombie() ) { cout << "There is something wrong with " << names_d[i] << "d. Please fix: now exiting." << endl; return; } if (histf->IsZombie() ) { cout << "There is something wrong with " << names_f[i] << "f. Please fix: now exiting." << endl; return; } if ( i < taggedgraphs ) cout << " | TH1D : TH1F : D/F " << endl; else cout << " | TH1D : TH1F : D/F " << endl; double totd = 0, totf = 0; for( int j = 0; j < nbins; j++ ) { if ( i < taggedgraphs ) { printf("%2i| %10.0f : %-10.0f : %5.4f\n",j,histd->GetBinContent(j),histf->GetBinContent(j),histd->GetBinContent(j)/histf->GetBinContent(j)); totd += histd->GetBinContent(j); totf += histf->GetBinContent(j); } else printf("%2i| %15.15f : %15.15f : %5.4f\n",j,histd->GetBinContent(j),histf->GetBinContent(j),histd->GetBinContent(j)/histf->GetBinContent(j)); }//go through the bins.. if ( i < taggedgraphs ) { cout << " " << endl; printf("SUM %10.0f : %-10.0f : %5.4f\n",totd, totf, totd/totf); } cout << "-------------------------------------------------------------" << endl; }//end for myFiled.Close(); myFilef.Close(); cout << endl << " .. Done " << endl; } // end of function
void finalPlot(bool drawRatio = 1, int differential = 0, int nsel = 0, int ReBin = 1, TString XTitle = "p_{T,max}^{l} (GeV)", TString units = "", TString plotName = "XSLeadingPt_AN.root", TString outputName = "WW_LeadingPt_final", bool isLogY = false, double lumi = 19.5) { gInterpreter->ExecuteMacro("GoodStyle.C"); TFile* file = new TFile(plotName.Data(), "read"); TH1F* xsValue = (TH1F*) xsValue->Clone(); TH1F* xsValue_Powheg = (TH1F*) xsValue_Powheg->Clone(); TH1F* xsValue_Madgraph = (TH1F*) xsValue_Madgraph->Clone(); TH1F* xsValue_MCnlo = (TH1F*) xsValue_MCnlo->Clone(); TH1F* systHisto = (TH1F*) systHisto->Clone(); TCanvas* canvas ; TPad *pad1, *pad2; if (drawRatio) { canvas = new TCanvas("wwxs", "wwxs", 550, 1.2*600); pad1 = new TPad("pad1", "pad1", 0, 0.3, 1, 1); pad1->SetTopMargin (0.05); pad1->SetBottomMargin(0.02); pad1->Draw(); pad2 = new TPad("pad2", "pad2", 0, 0, 1, 0.31); pad2->SetTopMargin (0.08); pad2->SetBottomMargin(0.35); pad2->Draw(); } else { canvas = new TCanvas("wwxs", "wwxs", 550, 550); } if (drawRatio) pad1->cd(); //Plot Data xsValue->SetLineWidth(1); xsValue->SetMarkerSize(1.0); int NBins = xsValue->GetNbinsX(); for(int i=1; i <NBins; i++) { float err_stat = xsValue->GetBinError(i); float err_syst = systHisto->GetBinError(i); float err_total = sqrt(err_stat*err_stat + err_syst*err_syst); xsValue->SetBinError(i, err_total); } //-- Plot Powheg TH1F *hpowError = (TH1F*) xsValue_Powheg->Clone(); xsValue_Powheg->SetMarkerColor(kAzure-3); xsValue_Powheg->SetLineWidth(1); xsValue_Powheg->SetLineColor(kBlue+2); xsValue_Powheg->SetMarkerStyle(22); xsValue_Powheg->SetMarkerSize(1.2); hpowError->SetLineWidth(0); hpowError->SetMarkerSize ( 0); hpowError->SetFillColor (kAzure-9); //-- Plot Madgraph TH1F *hmadError = (TH1F*) xsValue_Madgraph->Clone(); xsValue_Madgraph->SetMarkerColor(kPink-9); xsValue_Madgraph->SetLineWidth(1); xsValue_Madgraph->SetLineStyle(1); xsValue_Madgraph->SetMarkerStyle(21); xsValue_Madgraph->SetMarkerSize(1.0); hmadError->SetLineWidth(0); hmadError->SetMarkerSize ( 0); hmadError->SetFillColor (kPink+1); //-- Plot MCNLO TH1F *hmcError = (TH1F*) xsValue_MCnlo->Clone(); xsValue_MCnlo->SetMarkerColor(kRed); xsValue_MCnlo->SetLineColor(kRed); xsValue_MCnlo->SetLineWidth(1); xsValue_MCnlo->SetLineStyle(1); xsValue_MCnlo->SetMarkerStyle(24); xsValue_MCnlo->SetMarkerSize(1.0); hmcError->SetLineWidth(0); hmcError->SetMarkerSize ( 0); hmcError->SetFillColor (kOrange); //-- Plot Data xsValue->SetMarkerStyle(kFullCircle); if (differential == 0) AxisFonts (xsValue->GetYaxis(), "#frac{1}{#sigma} #frac{d#sigma}{dp_{T,max}^{l}}"); if (differential == 1) AxisFonts (xsValue->GetYaxis(), "#frac{1}{#sigma} #frac{d#sigma}{dp_{T}(ll)}"); if (differential == 2) AxisFonts (xsValue->GetYaxis(), "#frac{1}{#sigma} #frac{d#sigma}{dm_{#font[12]{ll}}}"); if (differential == 3) AxisFonts (xsValue->GetYaxis(), "#frac{1}{#sigma} #frac{d#sigma}{d#Delta#phi_{ll}}"); AxisFonts (xsValue->GetXaxis(), XTitle); xsValue->Draw("p"); hmadError->Draw("e2,same"); xsValue_Madgraph->Draw("pe1,same"); hmcError->Draw("e2,same"); xsValue_MCnlo->Draw("pe1,same"); hpowError->Draw("e2,same"); xsValue_Powheg->Draw("pe1,same"); //systHisto->Draw("e2, same"); xsValue->Draw("pe1,same"); // Legend //---------------------------------------------------------------------------- DrawLegend (0.65, 0.85, xsValue, "Data", "P"); DrawLegend (0.65, 0.80, hpowError, "", "F"); DrawLegend (0.65, 0.80, xsValue_Powheg, "Powheg", "PL"); DrawLegend (0.65, 0.75, hmadError, "", "F"); DrawLegend (0.65, 0.75, xsValue_Madgraph, "Madgraph", "PL"); DrawLegend (0.65, 0.70, hmcError, "", "F"); DrawLegend (0.65, 0.70, xsValue_MCnlo, "MCNLO", "LP"); canvas->GetFrame()->DrawClone(); // Draw text //---------------------------------------------------------------------------- TLatex * CMSLabel = new TLatex (0.18, 0.96, "#bf{CMS}"); CMSLabel->SetNDC (); CMSLabel->SetTextAlign (10); CMSLabel->SetTextFont (42); CMSLabel->SetTextSize (_tsize); CMSLabel->Draw ("same") ; TLatex * _lumiLabel = new TLatex (0.95, 0.96, "19.4fb#lower[0.3]{^{-1}} (8 TeV)"); _lumiLabel->SetNDC (); _lumiLabel->SetTextAlign (30); _lumiLabel->SetTextFont (42); _lumiLabel->SetTextSize (_tsize); _lumiLabel->Draw ("same") ; // Draw also ratio //---------------------------------------------------------------------------- if (drawRatio) { pad2->cd(); TH1F* ratio_pow = xsValue_Powheg->Clone("ratio"); TH1F* ratio_mad = xsValue_Madgraph->Clone("ratio"); TH1F* ratio_mcnlo = xsValue_MCnlo->Clone("ratio"); TH1F* hratio_pow = xsValue_Powheg->Clone("ratio"); TH1F* hratio_mad = xsValue_Madgraph->Clone("ratio"); TH1F* hratio_mcnlo = xsValue_MCnlo->Clone("ratio"); TH1F* ratioErr = xsValue->Clone("ratio"); for (UInt_t ibin=1; ibin<=ratio->GetNbinsX(); ibin++) { Double_t powValue = xsValue_Powheg->GetBinContent(ibin); Double_t powError = xsValue_Powheg->GetBinError (ibin); Double_t madValue = xsValue_Madgraph->GetBinContent(ibin); Double_t madError = xsValue_Madgraph->GetBinError (ibin); Double_t mcnloValue = xsValue_MCnlo->GetBinContent(ibin); Double_t mcnloError = xsValue_MCnlo->GetBinError (ibin); Double_t dataValue = xsValue->GetBinContent(ibin); Double_t statError = xsValue->GetBinError (ibin); Double_t systError = systHisto->GetBinError(ibin); Double_t dataError = systError; Double_t ratioValue_pow = (powValue > 0) ? powValue/dataValue : 0.0; Double_t ratioError_pow = (powValue > 0) ? powError / dataValue : 0.0; Double_t ratioValue_mad = (madValue > 0) ? madValue/dataValue : 0.0; Double_t ratioError_mad = (madValue > 0) ? madError/dataValue : 0.0; Double_t ratioValue_mcnlo = (mcnloValue > 0) ? mcnloValue/dataValue : 0.0; Double_t ratioError_mcnlo = (mcnloValue > 0) ? mcnloError/dataValue : 0.0; Double_t uncertaintyError = (dataValue > 0) ? dataError/dataValue : 0.0; //dataError/dataValue ratio_pow->SetBinContent(ibin, ratioValue_pow); hratio_pow->SetBinContent(ibin, ratioValue_pow); hratio_pow->SetBinError (ibin, ratioError_pow); ratio_mad->SetBinContent(ibin, ratioValue_mad); hratio_mad->SetBinContent(ibin, ratioValue_mad); hratio_mad->SetBinError (ibin, ratioError_mad); ratio_mcnlo->SetBinContent(ibin, ratioValue_mcnlo); hratio_mcnlo->SetBinContent(ibin, ratioValue_mcnlo); hratio_mcnlo->SetBinError (ibin, ratioError_mcnlo); ratioErr->SetBinContent(ibin, 1.0); ratioErr->SetBinError (ibin, uncertaintyError); } ratioErr->SetTitle(""); ratioErr ->Draw("e2"); ratio_mad ->SetLineColor(kPink-9); ratio_mad ->SetMarkerSize(1.0); ratio_mad ->SetLineWidth(1); ratio_mad ->SetMarkerStyle(21); hratio_mad ->SetLineWidth(0); hratio_mad ->SetMarkerSize ( 0); hratio_mad ->SetFillColor (kPink+1); hratio_mad ->SetFillStyle (1001); hratio_mad ->Draw("e2,same"); ratio_mad ->Draw("e1p,same"); ratio_mcnlo ->SetLineColor(kRed); ratio_mcnlo ->SetMarkerSize(1.0); ratio_mcnlo ->SetLineWidth(1); ratio_mcnlo ->SetMarkerStyle(24); hratio_mcnlo ->SetLineWidth(0); hratio_mcnlo ->SetMarkerSize ( 0); hratio_mcnlo ->SetFillColor (kOrange); hratio_mcnlo ->SetFillStyle (1001); hratio_mcnlo ->Draw("e2,same"); ratio_mcnlo ->Draw("ep,same"); ratio_pow ->SetLineColor(kAzure-3); ratio_pow ->SetMarkerSize(1.2); ratio_pow ->SetLineWidth(1); ratio_pow ->SetMarkerStyle(22); hratio_pow ->SetLineWidth(0); hratio_pow ->SetMarkerSize ( 0); hratio_pow ->SetFillColor (kAzure-9); hratio_pow ->SetFillStyle (1001); hratio_pow ->Draw("e2,same"); ratio_pow ->Draw("e1p,same"); ratioErr->SetFillColor (kGray+2); ratioErr->SetFillStyle ( 3345); ratioErr->SetLineColor (kGray+2); ratioErr->SetMarkerColor(kGray+2); ratioErr->SetMarkerSize ( 0); ratioErr->Draw("sameaxis"); ratioErr->GetYaxis()->SetRangeUser(0.4, 1.6); AxisFontsRatio (ratioErr->GetYaxis(), "y", "MC/data"); AxisFontsRatio (ratioErr->GetXaxis(), "x", XTitle); } }
void cetaflatHFM12(int nIterN=1, double Ethr1=10, double Ethr2=150) { // for HFM, L and S separately // nIterN - number of iterations // Ethr1 and Ethr2 - E thresholds within which E is estimated gStyle->SetOptLogz(0); gStyle->SetMarkerSize(0.7); gStyle->SetMarkerStyle(20); gStyle->SetPadGridX(0); gStyle->SetPadGridY(0); gStyle->SetTitleOffset(1.7,"Y"); gStyle->SetTitleOffset(0.9,"X"); //gStyle->SetPadRightMargin(0.12); gStyle->SetPadRightMargin(0.03); gStyle->SetPadLeftMargin(0.18); //gStyle->SetNdivisions(516); gStyle->SetStatH(0.025); gStyle->SetStatW(0.3); gStyle->SetTitleW(0.4); gStyle->SetTitleX(0.28); gStyle->SetOptStat(0); gROOT->ForceStyle(); char ctit[245],ftit[245]; float etaBounds[14] = {2.853,2.964,3.139,3.314,3.489,3.664,3.839,4.013,4.191,4.363,4.538,4.716,4.889,5.205}; // ------Histos input: spectra of all channels----------------------------------- //sprintf(ftit,"%s","phi43val2012A"); //sprintf(ftit,"%s","phi2012A_May"); //sprintf(ftit,"%s","phiSym524_2012AB"); //sprintf(ftit,"%s","phiSym524newGain_2012AB"); //sprintf(ftit,"%s","phiSym524newGain_2012ABC"); //sprintf(ftit,"%s","phisymNewCond2012Cval"); //sprintf(ftit,"%s","phisymOldCond2012Cval"); //sprintf(ftit,"%s","phiSym533Gain507_2012D"); // sprintf(ftit,"%s","phiSym533Corr45Gain507_2012D"); // histo root file processed //sprintf(ctit,"/home/vodib/beam12/intercal/%s.root",ftit); sprintf(ctit,"hcal.root",ftit); TFile *fila = new TFile (ctit); cout<<"File= "<<ctit<<endl; TH1F *hcounter = new TH1F(*((TH1F*)fila->Get("phaseHF/hcounter"))); cout<<"Stat= "<<hcounter->GetBinContent(2)<<endl; cout<<"E within: "<<Ethr1<<" - "<<Ethr2<<endl; TH2F* hLmapP = new TH2F("hLmapP","E L HFM;i#eta;i#phi",13,-41.5,-28.5,36,0,72); TH2F* hSmapP = new TH2F("hSmapP","E S HFM;i#eta;i#phi",13,-41.5,-28.5,36,0,72); TH2F* hLmapM0 = new TH2F("hLmapM0","E0 L HFM;i#eta;i#phi",13,-41.5,-28.5,36,0,72); TH2F* hSmapM0 = new TH2F("hSmapM0","E0 S HFM;i#eta;i#phi",13,-41.5,-28.5,36,0,72); TH2F* hLmapPc = new TH2F("hLmapPc","corr L HFM;i#eta;i#phi",13,-41.5,-28.5,36,0,72); TH2F* hSmapPc = new TH2F("hSmapPc","corr S HFM;i#eta;i#phi",13,-41.5,-28.5,36,0,72); hLmapPc->Sumw2(); hSmapPc->Sumw2(); //TH1F *hLcorr1D = new TH1F("hLcorr1D","Corr L",300,0.5,2); //TH1F *hScorr1D = new TH1F("hScorr1D","Corr S",300,0.5,2); TH1F *hLcorr1D = new TH1F("hLcorr1D","Corr L",180,0.7,1.5); TH1F *hScorr1D = new TH1F("hScorr1D","Corr S",180,0.7,1.5); TH1F *hLdatP[13][36], *hSdatP[13][36], *hLdatPx[13][36], *hSdatPx[13][36]; for (int ii=0;ii<13;ii++) for (int jj=0;jj<36;jj++) { sprintf(ctit,"hL%d_%d",-29-ii,2*jj+1); hLdatP[ii][jj] = new TH1F(ctit,ctit,8000,0,250); sprintf(ctit,"hS%d_%d",-29-ii,2*jj+1); hSdatP[ii][jj] = new TH1F(ctit,ctit,8000,0,250); } TH1F *htL = new TH1F("htL","htL",20000,0,7e8/3.); TH1F *htS = new TH1F("htS","htS",20000,0,5e8/3.); //TH1F *htL = new TH1F("htL","htL",20000,0,4e8/40); //TH1F *htS = new TH1F("htS","htS",20000,0,2e8/40); TH1F *hLdatPx[13][36], *hSdatPx[13][36]; TCanvas *cLx[200],*cSx[200]; TSpline5 *ttL,*ttS; Double_t x,y,rPL,rPS,drPL,drPS,mLE,mSE,ermean,rms; Double_t xxL[1000],yyL[1000]; Double_t xxS[1000],yyS[1000]; Int_t nELP, nESP, nIter=0; Double_t mcorrL,scorrL,mcorrS,scorrS,erLP,erSP,rLP,drLP,rSP,drSP,corrL,corrS,dcorrL,dcorrS; double mLEphi[13],mSEphi[13],dmLEphi[13],dmSEphi[13]; TCanvas *ccxx = new TCanvas("ccxx","ccxx",100,300,900,500); ccxx->Divide(2,1); // loop over channels, for (int ii=0;ii<13;ii++) { // loop over HFM ieta (rings) //for (int ii=1;ii<2;ii++) { int ieta=-ii-29; mLE=mSE=0; // ------------------for initial condition int nmLE=0, nmSE=0; htL->Reset(); htS->Reset(); for (int ll=1;ll<=72;ll+=2) { // loop over channels within HFM ieta (ring) to get data int iphi=ll; if (abs(ieta)>39 && (iphi-1)%4==0) continue; //if (ieta==29 && iphi==67) continue; hSmapPc->SetBinContent(13-ii,ll/2+1,1); // initial correction set to 1 hLmapPc->SetBinContent(13-ii,ll/2+1,1); hSmapPc->SetBinError(13-ii,ll/2+1,1.e-6); // non-zero err required hLmapPc->SetBinError(13-ii,ll/2+1,1.e-6); sprintf(ctit,"phaseHF/espec/E_%d_%d_1",ieta,iphi); hLdatPx[ii][ll/2] = new TH1F(*((TH1F*)fila->Get(ctit))); // read spectrum from root file hLdatPx[ii][ll/2]->SetAxisRange(Ethr1,Ethr2); rLP = hLdatPx[ii][ll/2]->Integral()*hLdatPx[ii][ll/2]->GetMean(); // channel's total E between thresholds if (rLP>0) { htL->Fill(rLP); mLE += rLP; // ring's total E between thresholds nmLE++; } sprintf(ctit,"phaseHF/espec/E_%d_%d_2",ieta,iphi); hSdatPx[ii][ll/2] = new TH1F(*((TH1F*)fila->Get(ctit))); hSdatPx[ii][ll/2]->SetAxisRange(Ethr1,Ethr2); rSP = hSdatPx[ii][ll/2]->Integral()*hSdatPx[ii][ll/2]->GetMean(); if (rSP>0) { htS->Fill(rSP); mSE += rSP; nmSE++; } hLmapM0->SetBinContent(13-ii,ll/2+1,rLP); hSmapM0->SetBinContent(13-ii,ll/2+1,rSP); hSdatP[ii][ll/2]->SetAxisRange(Ethr1,Ethr2); } if (nmLE>0) mLE /= nmLE; // ring's <E> else continue; if (nmSE>0) mSE /= nmSE; else continue; ccxx->cd(1); htL->Draw("hist"); ccxx->cd(2); htS->Draw("hist"); ccxx->Update(); //histspec(htL,mLE,ermean,rms,4,3); //histspec(htS,mSE,ermean,rms,4,3); mLEphi[ii]=mLE; mSEphi[ii]=mSE; dmLEphi[ii]=htL->GetRMS(); dmSEphi[ii]=htS->GetRMS(); printf("ieta %2d : <E>L= %8.1f (%6.1f) x %d <E>S= %8.1f (%6.1f) x %d \n", ieta,mLE,dmLEphi[ii],nmLE,mSE,dmSEphi[ii],nmSE); for (int jj=1;jj<=72;jj+=2) { // loop over channels within HFM ieta (ring) to get correction int iphi=jj; if (abs(ieta)>39 && (iphi-1)%4==0) continue; for (nIter=1;nIter<nIterN;nIter++) { // loop over iterations, L channels corrL=hLmapPc->GetBinContent(13-ii,jj/2+1); // correction factor hLdatP[ii][jj/2]->Reset(); for (int kk=1;kk<=hLdatPx[ii][jj/2]->GetNbinsX();kk++) { xxL[kk-1]=hLdatPx[ii][jj/2]->GetBinCenter(kk); yyL[kk-1]=hLdatPx[ii][jj/2]->GetBinContent(kk); } ttL = new TSpline5("tt",xxL,yyL,1000,"",10,20); // spline function over spectrum to get // smoother image of spectrum to improve convergence for (int kk=1;kk<=hLdatP[ii][jj/2]->GetNbinsX();kk++) { x=hLdatP[ii][jj/2]->GetBinCenter(kk); y=hLdatP[ii][jj/2]->GetBinContent(kk); hLdatP[ii][jj/2]->Fill(x*corrL,ttL->Eval(x)/8.0); // smoother image of spectrum, // with E shifted (corrected) by correction factor; // factor 8 due to difference in bin size of spectrum and smoother image of spectrum. } ttL->Delete(); hLdatP[ii][jj/2]->SetAxisRange(Ethr1,Ethr2); rLP = hLdatP[ii][jj/2]->Integral()*hLdatP[ii][jj/2]->GetMean(); // E of corrected spectrum dcorrL=(rLP-mLE)/mLE; // estimator of difference between <E> and E of corrected spectrum if (rLP>0) drLP= sqrt(pow(hLdatP[ii][jj/2]->GetMeanError()/hLdatP[ii][jj/2]->GetMean(),2)+ 1.f/hLdatP[ii][jj/2]->Integral()+ pow(dcorrL/(1.0+sqrt((float) nIter)),2)); else drLP=1.e-6; if (fabs(dcorrL)>0.001) { corrL*=1-dcorrL/(1.0+sqrt((float) nIter)); // new correction factor //printf("%2d : %2d / %2d / 1 %7.3f %7.3f\n",nIter,ieta,iphi,dcorrL,corrL); hLmapPc->SetBinContent(13-ii,jj/2+1,corrL); hLmapPc->SetBinError(13-ii,jj/2+1,corrL*drLP); hLmapP->SetBinContent(13-ii,jj/2+1,rLP); } else { printf("%2d : %2d / %2d / 1 %7.3f %8.4f %8.4f\n",nIter,ieta,iphi,dcorrL,corrL,corrL*drLP); hLmapP->SetBinContent(13-ii,jj/2+1,rLP); hLmapPc->SetBinError(13-ii,jj/2+1,corrL*drLP); break; } if (nIter==nIterN-1) { printf("%2d : %2d / %2d / 1 %7.3f %8.4f %8.4f\n",nIter,ieta,iphi,dcorrL,corrL,corrL*drLP); } } for (nIter=1;nIter<nIterN;nIter++) { corrS=hSmapPc->GetBinContent(13-ii,jj/2+1); hSdatP[ii][jj/2]->Reset(); for (int kk=1;kk<=hSdatPx[ii][jj/2]->GetNbinsX();kk++) { xxS[kk-1]=hSdatPx[ii][jj/2]->GetBinCenter(kk); yyS[kk-1]=hSdatPx[ii][jj/2]->GetBinContent(kk); } ttS = new TSpline5("tt",xxS,yyS,1000,"",10,20); for (int kk=1;kk<=hSdatP[ii][jj/2]->GetNbinsX();kk++) { x=hSdatP[ii][jj/2]->GetBinCenter(kk); y=hSdatP[ii][jj/2]->GetBinContent(kk); hSdatP[ii][jj/2]->Fill(x*corrS,ttS->Eval(x)/8.0); } ttS->Delete(); hSdatP[ii][jj/2]->SetAxisRange(Ethr1,Ethr2); rSP = hSdatP[ii][jj/2]->Integral()*hSdatP[ii][jj/2]->GetMean(); dcorrS=(rSP-mSE)/mSE; if (rSP>0) drSP=sqrt(pow(hSdatP[ii][jj/2]->GetMeanError()/hSdatP[ii][jj/2]->GetMean(),2)+ 1.f/hSdatP[ii][jj/2]->Integral()+ pow(dcorrS/(1.0+sqrt((float) nIter)),2)); else drSP=1.e-6; if (fabs(dcorrS)>0.001) { corrS*=1-dcorrS/(1.0+sqrt((float) nIter)); //printf("%2d : %2d / %2d / 1 %7.3f %7.3f\n",nIter,ieta,iphi,dcorrS,corrS); hSmapPc->SetBinContent(13-ii,jj/2+1,corrS); hSmapPc->SetBinError(13-ii,jj/2+1,corrS*drSP); hSmapP->SetBinContent(13-ii,jj/2+1,rSP); } else { printf("%2d : %2d / %2d / 2 %7.3f %8.4f %8.4f\n",nIter,ieta,iphi,dcorrS,corrS,corrS*drSP); hSmapP->SetBinContent(13-ii,jj/2+1,rSP); hSmapPc->SetBinError(13-ii,jj/2+1,corrS*drSP); break; } if (nIter==nIterN-1) { printf("%2d : %2d / %2d / 2 %7.3f %8.4f %8.4f\n",nIter,ieta,iphi,dcorrS,corrS,corrS*drSP); } } } } //fila->Close(); cout<<endl<<"Rings : "<<endl; cout<<" E L "<<"E S "<<"eta "<<"delta eta"<<endl; double xeta[13], weta[13], reta[13]; for (int i=0;i<13;i++) { xeta[i]=-(etaBounds[i+1]+etaBounds[i])/2; weta[i]=(etaBounds[i+1]-etaBounds[i]); mLEphi[i]=mLEphi[i]*36/weta[i]; mSEphi[i]=mSEphi[i]*36/weta[i]; dmLEphi[i]=dmLEphi[i]*36/weta[i]; dmSEphi[i]=dmSEphi[i]*36/weta[i]; if (i>10) { mLEphi[i]/=2; mSEphi[i]/=2; dmLEphi[i]/=2; dmSEphi[i]/=2; } reta[i] = mSEphi[i]/mLEphi[i]; cout<<i<<" : "<<mLEphi[i]<<" "<<mSEphi[i]<<" "<<xeta[i]<<" "<<weta[i]<<endl; } TCanvas *cgL = new TCanvas("cgL","cgL",300,300,600,600); TGraphErrors *grL = new TGraphErrors(13,xeta,mLEphi,0,dmLEphi); grL->SetName("grL"); grL->SetTitle("HFM L;#eta;E_{Ring} / #Delta#eta_{Ring} , GeV"); grL->SetMinimum(0); grL->SetMarkerStyle(20); grL->Draw("1+PAl"); cgL->Print("pictHFplot/etaProfHFML.gif"); //cgL->Print("pictHFmc/etaProfHFML.gif"); mSEphi[12]/=2; mSEphi[11]/=2; TCanvas *cgS = new TCanvas("cgS","cgS",300,300,600,600); TGraphErrors *grS = new TGraphErrors(13,xeta,mSEphi,0,dmSEphi); grS->SetName("grS"); grS->SetTitle("HFM S;#eta;E_{Ring} / #Delta#eta_{Ring} , GeV"); grS->SetMinimum(0); grS->SetMarkerStyle(20); grS->Draw("1+PAl"); cgS->Print("pictHFplot/etaProfHFMS.gif"); //cgS->Print("pictHFmc/etaProfHFMS.gif"); TCanvas *crg = new TCanvas("crg","crg",300,300,600,600); TGraphErrors *rg = new TGraphErrors(13,xeta,reta,0,0); rg->SetTitle("HFM;#eta;E(S) / E(L)"); rg->SetMinimum(0); rg->Draw("1+PAl"); crg->Print("pictHFplot/SoverLetaHFM.gif"); //crg->Print("pictHFmc/SoverLetaHFM.gif"); TCanvas *cL0 = new TCanvas("cL0","cL0",0,0,650,600); hLmapM0->Draw("colz"); cL0->Update(); TCanvas *cS = new TCanvas("cS0","cS0",1000,0,650,600); hSmapM0->Draw("colz"); cS0->Update(); //TFile *histf = new TFile("HFMmc.root","RECREATE"); FILE *ft1; //sprintf(ctit,"corrHFMmc_%d_%d.txt",((int) Ethr1),((int) Ethr2)); sprintf(ctit,"corrHFM_%s_%d_%d.txt",ftit,((int) Ethr1),((int) Ethr2)); if ((ft1 = fopen(ctit,"w"))==NULL){ // Open new file printf("\nNo file %s open => EXIT\n\n",file); return; } printf("\n\n File '%s' open \n\n",ctit); TH1D *hprL[13],*hprS[13],*hprL0[13],*hprS0[13]; TH1D *hprcL[13],*hprcS[13]; TCanvas *cpr[13],*ccc[13]; TLine *lin1 = new TLine(0,1,71,1); lin1->SetLineWidth(1); int noff=0; for (int ii=0;ii<13;ii++) { int ieta=-ii-29; sprintf(ctit,"HFMcorr_%d_L",-ii-29); // draw corrections hprcL[ii] = hLmapPc->ProjectionY(ctit,13-ii,13-ii); hprcL[ii]->SetTitle(ctit); sprintf(ctit,"HFMcorr_%d_S",-ii-29); hprcS[ii] = hSmapPc->ProjectionY(ctit,13-ii,13-ii); hprcS[ii]->SetTitle(ctit); ccc[ii] = new TCanvas(ctit,ctit,800,100,500,900); ccc[ii]->Divide(1,2); ccc[ii]->cd(1); if (abs(ieta)>39) { hprcL[ii]->Rebin(2); hprcS[ii]->Rebin(2); } hprcL[ii]->SetMinimum(0); hprcL[ii]->SetTitleOffset(0.9,"X"); hprcL[ii]->Draw("e"); lin1->Draw(); ccc[ii]->cd(2); hprcS[ii]->SetMinimum(0); hprcS[ii]->SetTitleOffset(0.9,"X"); hprcS[ii]->Draw("e"); lin1->Draw(); sprintf(ctit,"pictHFplot/HFMcorr_%d.gif",ii+29); //sprintf(ctit,"pictHFmc/HFMcorr_%d.gif",ii+29); ccc[ii]->Update(); ccc[ii]->Print(ctit); //hprcL[ii]->Write(); //hprcS[ii]->Write(); sprintf(ctit,"HFM_%d_L",-29-ii); // draw E depositions hprL0[ii] = hLmapM0->ProjectionY(ctit,13-ii,13-ii); sprintf(ctit,"HFM_%d_L;i#phi;GeV;",-29-ii); // draw E depositions hprL0[ii]->SetTitle(ctit); sprintf(ctit,"HFM_L_%d",-29-ii); hprL[ii] = hLmapP->ProjectionY(ctit,13-ii,13-ii); sprintf(ctit,"HFM_%d_S",-29-ii); hprS0[ii] = hSmapM0->ProjectionY(ctit,13-ii,13-ii); sprintf(ctit,"HFM_%d_S;i#phi;GeV;",-29-ii); // draw E depositions hprS0[ii]->SetTitle(ctit); sprintf(ctit,"HFM_S_%d",-29-ii); hprS[ii] = hSmapP->ProjectionY(ctit,13-ii,13-ii); cpr[ii] = new TCanvas(ctit,ctit,800,100,500,900); cpr[ii]->Divide(1,2); cpr[ii]->cd(1); if (abs(ieta)>39) { hprL0[ii]->Rebin(2); hprL[ii]->Rebin(2); hprS0[ii]->Rebin(2); hprS[ii]->Rebin(2); } hprL0[ii]->SetFillColor(3);hprL0[ii]->SetLineColor(3);hprL0[ii]->SetLineWidth(3); hprL0[ii]->SetMinimum(0); hprL0[ii]->SetTitleOffset(0.9,"X"); hprL0[ii]->Draw("hist"); hprL[ii]->Draw("samehist"); cpr[ii]->cd(2); hprS0[ii]->SetMinimum(0); hprS0[ii]->SetTitleOffset(0.9,"X"); hprS0[ii]->SetFillColor(3);hprS0[ii]->SetLineColor(3);hprS0[ii]->SetLineWidth(3); hprS0[ii]->Draw("hist"); hprS[ii]->Draw("samehist"); sprintf(ctit,"pictHFplot/HFM_%d.gif",ii+29); //sprintf(ctit,"pictHFmc/HFM_10_100G_%d.gif",ii+29); cpr[ii]->Update(); cpr[ii]->Print(ctit); //hprS0[ii]->Write(); //hprL0[ii]->Write(); cout<<"Results : "<<endl; for (int jj=1;jj<=72;jj+=2) { int ieta=-ii-29; int iphi=jj; if (abs(ieta)>39 && (iphi-1)%4==0) continue; //if (ieta==29 && iphi==67) continue; corrL=hLmapPc->GetBinContent(13-ii,jj/2+1); corrS=hSmapPc->GetBinContent(13-ii,jj/2+1); dcorrL=hLmapPc->GetBinError(13-ii,jj/2+1); dcorrS=hSmapPc->GetBinError(13-ii,jj/2+1); // -------------------------------------------------------------- !!! //if (abs(ieta)>29 && abs(ieta)<41) hLcorr1D->Fill(corrL); hScorr1D->Fill(corrS); noff++; //printf("%2d : %2d / %2d / 1 %9.4f %9.4f\n",noff,ieta,iphi,corrL,dcorrL); fprintf(ft1,"%2d %2d 1 %9.4f %9.4f\n",ieta,iphi,corrL,dcorrL); noff++; //printf("%2d : %2d / %2d / 2 %9.4f %9.4f\n",noff,ieta,iphi,corrS,dcorrS); fprintf(ft1,"%2d %2d 2 %9.4f %9.4f\n",ieta,iphi,corrS,dcorrS); } } fclose(ft1); for (int ii=0;ii<13;ii++) for (int jj=1;jj<=72;jj+=2) { int ieta=-ii-29; int iphi=jj; if (abs(ieta)>39 && (iphi-1)%4==0) continue; //if (ieta==29 && iphi==67) continue; corrL=hLmapPc->GetBinContent(13-ii,jj/2+1); if (fabs(corrL-1)>0.16) printf("%2d / %2d / 1 %9.4f %9.4f\n",ieta,iphi,corrL,dcorrL); corrS=hSmapPc->GetBinContent(13-ii,jj/2+1); if (fabs(corrS-1)>0.16) printf("%2d / %2d / 2 %9.4f %9.4f\n",ieta,iphi,corrS,dcorrS); } TCanvas *cLcorr =new TCanvas("cLcorr","cLcorr",30,30,600,600); cLcorr->SetRightMargin(0.12); hLmapPc->SetAxisRange(0.6,1.6,"Z"); hLmapPc->Draw("colz"); TCanvas *cScorr =new TCanvas("cScorr","cScorr",30,300,600,600); cScorr->SetRightMargin(0.12); hSmapPc->SetAxisRange(0.6,1.6,"Z"); hSmapPc->Draw("colz"); TCanvas *cL = new TCanvas("cL","cL",0,0,650,600); hLmapP->Draw("colz"); cL->Update(); TCanvas *cS = new TCanvas("cS","cS",1000,0,650,600); hSmapP->Draw("colz"); cS->Update(); TCanvas *c1corr =new TCanvas("c1corr","c1corr",30,30,900,500); c1corr->Divide(2,1); c1corr->cd(1); hLcorr1D->Draw("hist"); histStat(hLcorr1D,1); c1corr->cd(2); hScorr1D->Draw("hist"); histStat(hScorr1D,1); c1corr->Print("pictHFplot/corrHFM.gif"); //c1corr->Print("pictHFmc/corrM.gif"); c1corr->Update(); //fila->Close(); //histf->Close(); sprintf(ctit,"HFMo_%s_%d_%d.root",ftit,((int) Ethr1),((int) Ethr2)); TFile *histf = new TFile(ctit,"RECREATE"); hLcorr1D->Write(); hScorr1D->Write(); hLmapP->Write(); hLmapM0->Write(); hLmapPc->Write(); hSmapP->Write(); hSmapM0->Write(); hSmapPc->Write(); grL->Write(); grS->Write(); histf->Close(); }
void hand_target_asymmetry(){ bool includeVetos; // If includeVetos = false, then only good bars will be displayed. If // includeVetos = true, then veto bars will be shown along with the good bars. includeVetos = true; // includeVetos = false; bool includeAntivetos; // If includeAntivetos = false, then only good bars will be displayed. If // includeAntivetos = true, then antiveto bars will be shown along with the good bars. // includeAntivetos = true; includeAntivetos = false; bool antivetosAsVetos; // If antivetosAsVetos = false, then the antivetos will not be included in the veto cut // If antivetosAsVetos = true, then the antivetos will be included in the veto cut // Discusses elsewhere, antivetos are the bars immediately following a goodBar antivetosAsVetos = false; // antivetosAsVetos = true; bool drawCuts = true; // bool drawCuts = false; // The SinglePlane and SingleBar booleans skip the loop that goes over // ever bar into just a single plane and/or a single bar. bool SinglePlane; bool SingleBar; int singleplane; int singlebar; // SinglePlane = true; SinglePlane = false; singleplane = 2; // SingleBar = true; SingleBar = false; singlebar = 10; /* int HeRunNumber = 22441; int endHeRunNumber = 22441; TString Q2 = "1.0"; double q2min = 0.75; double q2max = 1.2; double numin = 0.3; double numax = 0.7; int Positionbins = 30; double Positionmin = -30; double Positionmax = 30; int TDCbins = 100; double TDCmin = 700; double TDCmax = 800; int ADCbins = 700; double ADCmin = -100; double ADCmax = 11100; double goodTDCleftcutmin = 752; double goodTDCleftcutmax = 775; double goodTDCrightcutmin = 752; double goodTDCrightcutmax = 775; double vetoTDCcutmin = 750; double vetoTDCcutmax = 785; */ /* // ********* Vertical, Q2=1.0 ******************* int HeRunNumber = 20596; int endHeRunNumber = 20683; TString Q2 = "1.0"; double q2min = 0.75; double q2max = 1.2; double numin = 0.3; double numax = 0.7; int Positionbins = 30; double Positionmin = -30; double Positionmax = 30; int TDCbins = 200; double TDCmin = 1300; double TDCmax = 1700; int ADCbins = 700; double ADCmin = -100; double ADCmax = 11100; double goodTDCleftcutmin = 1385; double goodTDCleftcutmax = 1415; double goodTDCrightcutmin = 1385; double goodTDCrightcutmax = 1415; double vetoTDCcutmin = 1385; double vetoTDCcutmax = 1415; */ /* // ********* Vertical, Q2=0.5 ******************* int HeRunNumber = 20890; int endHeRunNumber = 20890; TString Q2 = "0.5"; double q2min = 0.3; double q2max = 0.6; double numin = 0.1; double numax = 0.35; int Positionbins = 30; double Positionmin = -30; double Positionmax = 30; int TDCbins = 75; double TDCmin = 1300; double TDCmax = 1500; int ADCbins = 700; double ADCmin = -100; double ADCmax = 11100; double goodTDCleftcutmin = 1385; double goodTDCleftcutmax = 1415; double goodTDCrightcutmin = 1385; double goodTDCrightcutmax = 1415; double vetoTDCcutmin = 1385; double vetoTDCcutmax = 1415; */ /* // ********* Vertical, Q2=0.42 ******************* int HeRunNumber = 21383; int endHeRunNumber = 21387; TString Q2 = "0.42"; double q2min = 0.33; double q2max = 0.51; double numin = 0.17; double numax = 0.3; int Positionbins = 30; double Positionmin = -30; double Positionmax = 30; int TDCbins = 50; double TDCmin = 700; double TDCmax = 800; int ADCbins = 700; double ADCmin = -100; double ADCmax = 11100; double goodTDCleftcutmin = 730; double goodTDCleftcutmax = 770; double goodTDCrightcutmin = 740; double goodTDCrightcutmax = 780; double vetoTDCcutmin = 730; double vetoTDCcutmax = 770; */ /* int HeRunNumber = 21714; int endHeRunNumber = 22248; TString Q2 = "0.52"; double q2min = 0.33; double q2max = 0.62; double numin = 0.17; double numax = 0.35; int Positionbins = 30; double Positionmin = -30; double Positionmax = 30; int TDCbins = 50; double TDCmin = 700; double TDCmax = 800; int ADCbins = 700; double ADCmin = -100; double ADCmax = 11100; double goodTDCleftcutmin = 730; double goodTDCleftcutmax = 770; double goodTDCrightcutmin = 740; double goodTDCrightcutmax = 780; double vetoTDCcutmin = 730; double vetoTDCcutmax = 770; */ // ********* Transverse, Q2=1.0 ******************* int HeRunNumber = 22447; int endHeRunNumber = 22447; TString Q2 = "1.0"; double q2min = 0.75; double q2max = 1.2; double numin = 0.3; double numax = 0.7; int Positionbins = 30; double Positionmin = -30; double Positionmax = 30; int TDCbins = 100; double TDCmin = 650; double TDCmax = 850; int ADCbins = 700; double ADCmin = -100; double ADCmax = 11100; double goodTDCleftcutmin = 745; double goodTDCleftcutmax = 775; double goodTDCrightcutmin = 750; double goodTDCrightcutmax = 780; double vetoTDCcutmin = 745; double vetoTDCcutmax = 780; const int xBjbins = 50; double xBjmin = 0.6; double xBjmax = 1.6; double xmin = 0.6; double xmax = 3.0; int bins = 50; TString outputPlotsHere = "/home/ellie/physics/e05-102/images/plots_for_hand/hand_target_asymmetry/"; TString asymOutFileName = outputPlotsHere; asymOutFileName += "target_asymmetry_for_runs_"; asymOutFileName += HeRunNumber; asymOutFileName += "-"; asymOutFileName += endHeRunNumber; asymOutFileName += ".txt"; ofstream asymOutFile; asymOutFile.open(asymOutFileName); // Although declared here, the goodTDCcut is actually made down below where it can be included // in the loop so that it is easy to have it change for each good bar when done one at a time. // However, the left and right min and max TDC values are defined here TCut goodTDCcut = ""; TChain* chainHe = new TChain("T"); TString filenameHe; for (int thisHeRunNumber=HeRunNumber; thisHeRunNumber<(endHeRunNumber+1); thisHeRunNumber++) { // Skipping Vertical Non-Production Runs if(thisHeRunNumber==20591){thisHeRunNumber=20596;} if(thisHeRunNumber==20731){thisHeRunNumber=20738;} if(thisHeRunNumber==20732){thisHeRunNumber=20738;} if(thisHeRunNumber==20733){thisHeRunNumber=20738;} if(thisHeRunNumber==20734){thisHeRunNumber=20738;} if(thisHeRunNumber==20736){thisHeRunNumber=20738;} if(thisHeRunNumber==20737){thisHeRunNumber=20738;} if(thisHeRunNumber==20762){thisHeRunNumber=20789;} if(thisHeRunNumber==20763){thisHeRunNumber=20789;} if(thisHeRunNumber==20764){thisHeRunNumber=20789;} if(thisHeRunNumber==20791){thisHeRunNumber=20814;} if(thisHeRunNumber==20792){thisHeRunNumber=20814;} // Skipping Longitudinal Non-Production Runs if(thisHeRunNumber==22380){thisHeRunNumber=22393;} if(thisHeRunNumber==22389){thisHeRunNumber=22393;} if(thisHeRunNumber==22425){thisHeRunNumber=22436;} if(thisHeRunNumber==22426){thisHeRunNumber=22436;} // Skipping Transverse Non-Production Runs if(thisHeRunNumber==22461){thisHeRunNumber=22465;} for (int t=0; t<1000; t++) { filenameHe = "/home/ellie/physics/e05-102/ellana/ROOTfiles/e05102_R_"; filenameHe += thisHeRunNumber; if (t != 0) { filenameHe += "_"; filenameHe += t; } filenameHe += ".root"; ifstream ifileHe(filenameHe); if (ifileHe) { cout << "Adding file to chainHe: " << filenameHe << endl; chainHe->Add(filenameHe); } else { cout << "File " << filenameHe << " does not exist. Ending here." << endl; t=999999999; } TFile fileHe(filenameHe); } } gStyle->SetPalette(1); TCut cut = ""; TCut kinematics = ""; TCut eventtype = ""; TCut dp = ""; TCut target = ""; TCut tracks = ""; TCut thph = ""; TCut xbj = ""; TCut pssh = ""; TCut cerenkov = ""; TCut q2nu = ""; TCut basic = ""; TCut cuts = ""; TString imageCutsTitle = outputPlotsHere; imageCutsTitle += "HAND_plots_Run_Num_"; imageCutsTitle += HeRunNumber; imageCutsTitle += "-"; imageCutsTitle += endHeRunNumber; imageCutsTitle += "_basic_cuts"; if (includeVetos) imageCutsTitle += "_with_vetos"; if (includeAntivetos) {imageCutsTitle += "_with_antivetos";} if (antivetosAsVetos && includeAntivetos) {imageCutsTitle += "_as_vetos";} imageCutsTitle += ".png"; hand_basic_cuts(cut, kinematics, eventtype, dp, target, tracks, thph, xbj, pssh, cerenkov, q2nu, basic, cuts, imageCutsTitle, HeRunNumber, endHeRunNumber, chainHe, numin, numax, q2min, q2max, bins, xmin, xmax, drawCuts, Q2); TString cutstring = TString(cuts); cout << "Cuts: " << cutstring << endl; // ********************************************************************************************** gStyle->SetOptFit(1111); TString veto1plane = ""; TString veto1bar = ""; TString veto2plane = ""; TString veto2bar = ""; TString veto3plane = ""; TString veto3bar = ""; TString veto4plane = ""; TString veto4bar = ""; TString veto5plane = ""; TString veto5bar = ""; TString veto6plane = ""; TString veto6bar = ""; TString antiveto1plane = ""; TString antiveto1bar = ""; TString antiveto2plane = ""; TString antiveto2bar = ""; TString antiveto3plane = ""; TString antiveto3bar = ""; TString allVetos = ""; TString allAntivetos = ""; TString vetoTDCslSt = ""; TString vetoTDCsrSt = ""; TCut vetoTDCsl = ""; TCut vetoTDCsr = ""; TCut vetoTDCs = ""; TString antivetosTDCslSt = ""; TString antivetosTDCsrSt = ""; int maxbars = 0; int vetoplane = 0; int padBins = 0; double padMin = 0; double padMax = 0; // ********************************************************************************************** // This bit of code should set the charge and livetime scaling factors double HeChargeScale = 0; double Helivetime = 0; double HeChargeScaleUp = 0; double HelivetimeUp = 0; double HeChargeScaleDown = 0; double HelivetimeDown = 0; hand_scaling_factors(HeRunNumber, endHeRunNumber, HeChargeScale, Helivetime, HeChargeScaleUp, HelivetimeUp, HeChargeScaleDown, HelivetimeDown); HeChargeScale = 0.00001 * int(HeChargeScale * 100000.0 + 0.5); HeChargeScaleUp = 0.00001 * int(HeChargeScaleUp * 100000.0 + 0.5); HeChargeScaleDown = 0.00001 * int(HeChargeScaleDown * 100000.0 + 0.5); Helivetime = 0.0001 * int(Helivetime * 10000.0 + 0.5); HelivetimeUp = 0.0001 * int(HelivetimeUp * 10000.0 + 0.5); HelivetimeDown = 0.0001 * int(HelivetimeDown * 10000.0 + 0.5); cout << "HeChargeScale: " << HeChargeScale << "C, Helivetime: " << Helivetime << endl; cout << "HeChargeScaleUp: " << HeChargeScaleUp << "C, HelivetimeUp: " << HelivetimeUp << endl; cout << "HeChargeScaleDown: " << HeChargeScaleDown << "C, HelivetimeDown: " << HelivetimeDown << endl; // ********************************************************************************************** // The section below plots the HAND data // ********************************************************************************************** // int whichplane = 0; int whichplane = 1; int endplane = 5; if (SinglePlane) {whichplane = singleplane; endplane = singleplane+1;} int whichbar=0; // int whichbar=11; TString titleTotalSpinUpx = "Total Spin Up vs. xBj"; if (includeVetos) {titleTotalSpinUpx += " with vetos";} else {titleTotalSpinUpx += " without vetos";} titleTotalSpinUpx += " with goodTDC cuts"; cout << "Drawing " << titleTotalSpinUpx << "..." << endl; TString plotTotalSpinUpx = "HANDTotalSpinUpx"; TH1F *HANDTotalSpinUpx = new TH1F(plotTotalSpinUpx,titleTotalSpinUpx,xBjbins,xBjmin,xBjmax); TString titleTotalSpinDownx = "Total Spin Down vs. xBj"; if (includeVetos) {titleTotalSpinDownx += " with vetos";} else {titleTotalSpinDownx += " without vetos";} titleTotalSpinDownx += " with goodTDC cuts"; cout << "Drawing " << titleTotalSpinDownx << "..." << endl; TString plotTotalSpinDownx = "HANDTotalSpinDownx"; TH1F *HANDTotalSpinDownx = new TH1F(plotTotalSpinDownx,titleTotalSpinDownx,xBjbins,xBjmin,xBjmax); for (int nplane=whichplane; nplane<endplane; nplane++) { if (nplane==0) maxbars=32; if (nplane==1) maxbars=30; if (nplane==2) maxbars=24; if (nplane==3) maxbars=22; if (nplane==4) maxbars=12; if (SingleBar) {whichbar = singlebar; maxbars = singlebar + 1;} for (int thisbar=whichbar; thisbar<maxbars; thisbar++) { TString goodPlane = nplane; TString goodPMT = thisbar; hand_define_vetos(includeVetos, includeAntivetos, antivetosAsVetos, nplane, thisbar, veto1plane, veto2plane, veto3plane, veto4plane, veto5plane, veto6plane, veto1bar, veto2bar, veto3bar, veto4bar, veto5bar, veto6bar, antiveto1plane, antiveto2plane, antiveto3plane, antiveto1bar, antiveto2bar, antiveto3bar, allVetos, allAntivetos, vetoTDCslSt, vetoTDCsrSt, vetoTDCsl, vetoTDCsr, vetoTDCs, vetoTDCcutmin, vetoTDCcutmax, antivetosTDCslSt, antivetosTDCsrSt); TString goodBar = "nd.p"; goodBar += nplane; goodBar += "."; goodBar += thisbar; goodBar += " "; cout << "Good Bar: " << goodBar << endl; TString goodTDCl = "NA.nd.p"; goodTDCl += nplane; if (nplane == 0) goodTDCl = "NA.veto"; goodTDCl += ".lt_c["; goodTDCl += thisbar; goodTDCl += "]"; TString goodTDCr = "NA.nd.p"; goodTDCr += nplane; if (nplane == 0) goodTDCr = "NA.veto"; goodTDCr += ".rt_c["; goodTDCr += thisbar; goodTDCr += "]"; TString goodTDCs = goodTDCl; goodTDCs += ":"; goodTDCs += goodTDCr; TString goodADCl = "NA.nd.p"; goodADCl += nplane; if (nplane == 0) goodADCl = "NA.veto"; goodADCl += ".la_c["; goodADCl += thisbar; goodADCl += "]"; TString goodADCr = "NA.nd.p"; goodADCr += nplane; if (nplane == 0) goodADCr = "NA.veto"; goodADCr += ".ra_c["; goodADCr += thisbar; goodADCr += "]"; TString goodADCs = goodADCl; goodADCs += ":"; goodADCs += goodADCr; TString canvasName = "handp"; canvasName += nplane; canvasName += "b"; canvasName += thisbar; TString canvasTitle = "HAND - Plane "; canvasTitle += nplane; canvasTitle += ", Bar "; canvasTitle += thisbar; TCanvas *handCanvas = new TCanvas(canvasName,canvasTitle,1400,770); //x,y handpad01 = new TPad("handpad01","handpad01",0.0000,0.0000,0.1000,1.0000,0,0,0); handpad02 = new TPad("handpad02","handpad02",0.1000,0.6666,0.5500,1.0000,0,0,0); handpad03 = new TPad("handpad03","handpad03",0.5500,0.6666,1.0000,1.0000,0,0,0); handpad04 = new TPad("handpad04","handpad04",0.1000,0.3333,0.5500,0.6666,0,0,0); handpad05 = new TPad("handpad05","handpad05",0.5500,0.3333,1.0000,0.6666,0,0,0); handpad06 = new TPad("handpad06","handpad06",0.1000,0.0000,0.5500,0.3333,0,0,0); handpad07 = new TPad("handpad07","handpad07",0.5500,0.0000,1.0000,0.3333,0,0,0); handpad01->Draw(); handpad02->Draw(); handpad03->Draw(); handpad04->Draw(); handpad05->Draw(); handpad06->Draw(); handpad07->Draw(); // This section will run hand_draw.h which will draw the HAND in handpad01. handpad01->cd(); hand_draw(HeRunNumber, endHeRunNumber, antivetosAsVetos, allVetos, goodBar, allAntivetos); handpad01->Update(); TString goodTDCleftcutString = "(NA.nd.p"; goodTDCleftcutString += nplane; if (nplane == 0) {goodTDCleftcutString = "(NA.veto";} goodTDCleftcutString += ".lt_c["; goodTDCleftcutString += thisbar; goodTDCleftcutString += "]>"; goodTDCleftcutString += goodTDCleftcutmin; if (nplane > 0) { goodTDCleftcutString += " && NA.nd.p"; goodTDCleftcutString += nplane; } if (nplane == 0) {goodTDCleftcutString += " && NA.veto";} goodTDCleftcutString += ".lt_c["; goodTDCleftcutString += thisbar; goodTDCleftcutString += "]<"; goodTDCleftcutString += goodTDCleftcutmax; goodTDCleftcutString += ")"; cout << "goodTDCleftcutString = " << goodTDCleftcutString << endl; TCut goodTDCleftcut = goodTDCleftcutString; TString goodTDCrightcutString = "(NA.nd.p"; goodTDCrightcutString += nplane; if (nplane == 0) {goodTDCrightcutString = "(NA.veto";} goodTDCrightcutString += ".rt_c["; goodTDCrightcutString += thisbar; goodTDCrightcutString += "]>"; goodTDCrightcutString += goodTDCrightcutmin; if (nplane > 0) { goodTDCrightcutString += " && NA.nd.p"; goodTDCrightcutString += nplane; } if (nplane == 0) {goodTDCrightcutString += " && NA.veto";} goodTDCrightcutString += ".rt_c["; goodTDCrightcutString += thisbar; goodTDCrightcutString += "]<"; goodTDCrightcutString += goodTDCrightcutmax; goodTDCrightcutString += ")"; cout << "goodTDCrightcutString = " << goodTDCrightcutString << endl; TCut goodTDCrightcut = goodTDCrightcutString; TString firstTrackString = "NA.tr.firstplane=="; firstTrackString += (nplane - 1); firstTrackString += " && NA.tr.firstpad=="; firstTrackString += thisbar; TCut firstTrack = firstTrackString; goodTDCcut = (goodTDCleftcut || goodTDCrightcut); // cout << "Cuts: " << cutstring << endl; TString vetoCutString = TString(vetoTDCs); // cout << "Veto Cuts: " << vetoCutString << endl; handpad02->cd(); TString titleHANDleft = "Left TDC for Plane #"; titleHANDleft += nplane; titleHANDleft += ", PMT # "; titleHANDleft += thisbar; if (includeVetos) {titleHANDleft += " with vetos";} else {titleHANDleft += " without vetos";} cout << "Drawing " << titleHANDleft << "..." << endl; TString plotHANDleft = "HANDleft_p"; plotHANDleft += nplane; plotHANDleft += "_b"; plotHANDleft += thisbar; TString plotHANDleftcut = plotHANDleft; plotHANDleftcut += "_cut"; // cout << "plotHANDleft: " << plotHANDleft << ", plotHANDleftcut: " << plotHANDleftcut << endl; cout << "goodTDCl: " << goodTDCl << endl; TH1F *HANDleft = new TH1F(plotHANDleft,titleHANDleft,TDCbins,TDCmin,TDCmax); HANDleft->SetMinimum(0); TH1F *HANDleftcut = new TH1F(plotHANDleftcut,titleHANDleft,TDCbins,TDCmin,TDCmax); HANDleftcut->SetMinimum(0); TString HANDleftTDC = goodTDCl; HANDleftTDC += ">>"; HANDleftTDC += plotHANDleft; TString HANDleftTDCcut = goodTDCl; HANDleftTDCcut += ">>"; HANDleftTDCcut += plotHANDleftcut; chainHe->Draw(HANDleftTDC, cuts && vetoTDCs,""); // chainHe->Draw(HANDleftTDC, vetoTDCs,""); // HANDleft->Scale(1/(HeChargeScale*Helivetime)); HANDleft->Draw(); chainHe->Draw(HANDleftTDCcut, cuts && vetoTDCs && goodTDCleftcut && firstTrack,"same"); HANDleftcut->SetFillColor(kViolet); // HANDleftcut->Scale(1/(HeChargeScale*Helivetime)); HANDleftcut->Draw("same"); // ******************************************************************************** // This section below gathers and prints some statistics on the plot double numHANDleftcutEvents = 0; for (int i=0; i<TDCbins; i++){ numHANDleftcutEvents = numHANDleftcutEvents + HANDleftcut->GetBinContent(i);} TString HANDleftFactorsString = "Total Charge for Runs: "; HANDleftFactorsString += HeChargeScale; HANDleftFactorsString += " C"; TString HANDleftFactorsString1 = "Total Livetime for Runs: "; HANDleftFactorsString1 += Helivetime; TString HANDleftFactorsString2 = "# of Cut (Purple) Events: "; HANDleftFactorsString2 += numHANDleftcutEvents; HANDleftFactors = new TPaveText(0.11,0.69,0.4,0.89,"NDC"); TText *t1 = HANDleftFactors->AddText(HANDleftFactorsString); TText *t2 = HANDleftFactors->AddText(HANDleftFactorsString1); TText *t2 = HANDleftFactors->AddText(HANDleftFactorsString2); HANDleftFactors->Draw("same"); // ******************************************************************************** handpad02->Update(); handpad03->cd(); TString titleHANDright = "Right TDC for Plane #"; titleHANDright += nplane; titleHANDright += ", PMT # "; titleHANDright += thisbar; if (includeVetos) {titleHANDright += " with vetos";} else {titleHANDright += " without vetos";} TString plotHANDright = "HANDright_p"; plotHANDright += nplane; plotHANDright += "_b"; plotHANDright += thisbar; TString plotHANDrightcut = plotHANDright; plotHANDrightcut += "_cut"; cout << "Drawing " << titleHANDright << "..." << endl; TH1F *HANDright = new TH1F(plotHANDright,titleHANDright,TDCbins,TDCmin,TDCmax); HANDright->SetMinimum(0); TH1F *HANDrightcut = new TH1F(plotHANDrightcut,titleHANDright,TDCbins,TDCmin,TDCmax); HANDrightcut->SetMinimum(0); TString HANDrightTDC = goodTDCr; HANDrightTDC += ">>"; HANDrightTDC += plotHANDright; TString HANDrightTDCcut = goodTDCr; HANDrightTDCcut += ">>"; HANDrightTDCcut += plotHANDrightcut; chainHe->Draw(HANDrightTDC, cuts && vetoTDCs,""); // HANDright->Scale(1/(HeChargeScale*Helivetime)); HANDright->Draw(); chainHe->Draw(HANDrightTDCcut, cuts && vetoTDCs && goodTDCrightcut && firstTrack,"same"); HANDrightcut->SetFillColor(kViolet); // HANDrightcut->Scale(1/(HeChargeScale*Helivetime)); HANDrightcut->Draw("same"); // ******************************************************************************** // This section below gathers and prints some statistics on the plot double numHANDrightcutEvents = 0; for (int j=0; j<TDCbins; j++){ numHANDrightcutEvents = numHANDrightcutEvents + HANDrightcut->GetBinContent(j);} TString HANDrightFactorsString = "Total Charge for Runs: "; HANDrightFactorsString += HeChargeScale; HANDrightFactorsString += " C"; TString HANDrightFactorsString1 = "Total Livetime for Runs: "; HANDrightFactorsString1 += Helivetime; TString HANDrightFactorsString2 = "# of Cut (Purple) Events: "; HANDrightFactorsString2 += numHANDrightcutEvents; HANDrightFactors = new TPaveText(0.11,0.69,0.4,0.89,"NDC"); TText *t1 = HANDrightFactors->AddText(HANDrightFactorsString); TText *t2 = HANDrightFactors->AddText(HANDrightFactorsString1); TText *t2 = HANDrightFactors->AddText(HANDrightFactorsString2); HANDrightFactors->Draw("same"); // ******************************************************************************** handpad03->Update(); handpad04->cd(); cout << "Drawing Spin Up vs. xBj..." << endl; TString titleSpinUpx = "Spin Up vs. xBj for Plane #"; titleSpinUpx += nplane; titleSpinUpx += ", PMT # "; titleSpinUpx += thisbar; if (includeVetos) {titleSpinUpx += " with vetos";} else {titleSpinUpx += " without vetos";} TString titleSpinUpxcut = titleSpinUpx; titleSpinUpxcut += " with goodTDC cuts"; cout << "Drawing " << titleSpinUpx << "..." << endl; TString plotSpinUpx = "HANDSpinUpx_p"; plotSpinUpx += nplane; plotSpinUpx += "_b"; plotSpinUpx += thisbar; TH1F *HANDSpinUpx = new TH1F(plotSpinUpx,titleSpinUpxcut,xBjbins,xBjmin,xBjmax); TString HANDSpinUpxString = "PriKineR.x_bj"; HANDSpinUpxString += ">>"; HANDSpinUpxString += plotSpinUpx; chainHe->Draw(HANDSpinUpxString, cuts && vetoTDCs && goodTDCcut && firstTrack && "he3R.Spin==1",""); HANDSpinUpx->SetMinimum(0); HANDSpinUpx->Draw(); handpad04->Update(); handpad05->cd(); cout << "Drawing Spin Down vs. xBj..." << endl; TString titleSpinDownx = "Spin Down vs. xBj for Plane #"; titleSpinDownx += nplane; titleSpinDownx += ", PMT # "; titleSpinDownx += thisbar; if (includeVetos) {titleSpinDownx += " with vetos";} else {titleSpinDownx += " without vetos";} TString titleSpinDownxcut = titleSpinDownx; titleSpinDownxcut += " with goodTDC cuts"; cout << "Drawing " << titleSpinDownx << "..." << endl; TString plotSpinDownx = "HANDSpinDownx_p"; plotSpinDownx += nplane; plotSpinDownx += "_b"; plotSpinDownx += thisbar; TH1F *HANDSpinDownx = new TH1F(plotSpinDownx,titleSpinDownxcut,xBjbins,xBjmin,xBjmax); TString HANDSpinDownxString = "PriKineR.x_bj"; HANDSpinDownxString += ">>"; HANDSpinDownxString += plotSpinDownx; chainHe->Draw(HANDSpinDownxString, cuts && vetoTDCs && goodTDCcut && firstTrack && "he3R.Spin==-1",""); HANDSpinDownx->SetMinimum(0); HANDSpinDownx->Draw(); handpad05->Update(); handpad06->cd(); cout << "Drawing Total Spin Up vs. xBj..." << endl; // TString titleTotalSpinUpx = "Total Spin Up vs. xBj"; // if (includeVetos) {titleTotalSpinUpx += " with vetos";} // else {titleTotalSpinUpx += " without vetos";} // titleTotalSpinUpx += " with goodTDC cuts"; // cout << "Drawing " << titleTotalSpinUpx << "..." << endl; // TString plotTotalSpinUpx = "HANDTotalSpinUpx"; // TH1F *HANDTotalSpinUpx = new TH1F(plotTotalSpinUpx,titleTotalSpinUpx,xBjbins,xBjmin,xBjmax); HANDTotalSpinUpx->Add(HANDSpinUpx); HANDTotalSpinUpx->SetMinimum(0); HANDTotalSpinUpx->Draw(); handpad06->Update(); handpad07->cd(); cout << "Drawing Total Spin Down vs. xBj..." << endl; // TString titleTotalSpinDownx = "Total Spin Down vs. xBj"; // if (includeVetos) {titleTotalSpinDownx += " with vetos";} // else {titleTotalSpinDownx += " without vetos";} // titleTotalSpinDownx += " with goodTDC cuts"; // cout << "Drawing " << titleTotalSpinDownx << "..." << endl; // TString plotTotalSpinDownx = "HANDTotalSpinDownx"; // TH1F *HANDTotalSpinDownx = new TH1F(plotTotalSpinDownx,titleTotalSpinDownx,xBjbins,xBjmin,xBjmax); HANDTotalSpinDownx->Add(HANDSpinDownx); HANDTotalSpinDownx->SetMinimum(0); HANDTotalSpinDownx->Draw(); handpad07->Update(); TString imageTitle = outputPlotsHere; imageTitle += "TDC_plots_Run_Num_"; imageTitle += HeRunNumber; imageTitle += "-"; imageTitle += endHeRunNumber; imageTitle += "_p"; imageTitle += nplane; imageTitle += "_b"; if (thisbar < 10) {imageTitle += "0";} imageTitle += thisbar; if (includeVetos) {imageTitle += "_with_vetos";} if (includeAntivetos) {imageTitle += "_with_antivetos";} if (antivetosAsVetos && includeAntivetos) {imageTitle += "_as_vetos";} imageTitle+= ".png"; handCanvas->Print(imageTitle); TString imageAntivetosTitle = outputPlotsHere; imageAntivetosTitle += "antivetos_for_Run_Num_"; imageAntivetosTitle += HeRunNumber; imageAntivetosTitle += "-"; imageAntivetosTitle += endHeRunNumber; imageAntivetosTitle += "_p"; imageAntivetosTitle += nplane; imageAntivetosTitle += "_b"; imageAntivetosTitle += thisbar; if (includeVetos) {imageAntivetosTitle += "_with_vetos";} if (includeAntivetos) {imageAntivetosTitle += "_with_antivetos";} if (antivetosAsVetos && includeAntivetos) {imageAntivetosTitle += "_as_vetos";} imageAntivetosTitle += ".png"; if (includeAntivetos) {hand_draw_antivetos(antiveto1plane, antiveto1bar, antiveto2plane, antiveto2bar, antiveto3plane, antiveto3bar, HeRunNumber, endHeRunNumber, chainHe, TDCbins, TDCmin, TDCmax, cuts, goodTDCcut, vetoTDCs, imageAntivetosTitle, nplane, thisbar, includeVetos, includeAntivetos, antivetosAsVetos, veto1plane, veto1bar, veto2plane, veto2bar, veto3plane, veto3bar, veto4plane, veto4bar, veto5plane, veto5bar, veto6plane, veto6bar, allVetos, allAntivetos);} // ********************************************************************************************************* // The section below will plot the bars used for vetos for the previous canvas. It will consist of two // canvases, one without the veto cuts made and one with to show the different. TString imageVetosWithoutVetosTitle = outputPlotsHere; imageVetosWithoutVetosTitle += "vetos_without_veto_cut_for_Run_Num_"; imageVetosWithoutVetosTitle += HeRunNumber; imageVetosWithoutVetosTitle += "-"; imageVetosWithoutVetosTitle += endHeRunNumber; imageVetosWithoutVetosTitle += "_p"; imageVetosWithoutVetosTitle += nplane; imageVetosWithoutVetosTitle += "_b"; imageVetosWithoutVetosTitle += thisbar; if (includeVetos) {imageVetosWithoutVetosTitle += "_with_vetos";} if (includeAntivetos) {imageVetosWithoutVetosTitle += "_with_antivetos";} if (antivetosAsVetos && includeAntivetos) {imageVetosWithoutVetosTitle += "_as_vetos";} imageVetosWithoutVetosTitle+= ".png"; TString imageVetosWithVetosTitle = outputPlotsHere; imageVetosWithVetosTitle += "vetos_with_veto_cut_for_Run_Num_"; imageVetosWithVetosTitle += HeRunNumber; imageVetosWithVetosTitle += "-"; imageVetosWithVetosTitle += endHeRunNumber; imageVetosWithVetosTitle += "_p"; imageVetosWithVetosTitle += nplane; imageVetosWithVetosTitle += "_b"; imageVetosWithVetosTitle += thisbar; if (includeVetos) {imageVetosWithVetosTitle += "_with_vetos";} if (includeAntivetos) {imageVetosWithVetosTitle += "_with_antivetos";} if (antivetosAsVetos && includeAntivetos) {imageVetosWithVetosTitle += "_as_vetos";} imageVetosWithVetosTitle+= ".png"; // if (includeVetos) {hand_draw_vetos(veto1plane, veto2plane, veto3plane, veto4plane, veto5plane, veto6plane,veto1bar, veto2bar, veto3bar, veto4bar, veto5bar, veto6bar, imageVetosWithoutVetosTitle, imageVetosWithVetosTitle, HeRunNumber, endHeRunNumber, chainHe, nplane, thisbar, TDCbins, TDCmin, TDCmax, cuts, vetoTDCs, antivetosAsVetos, allVetos, allAntivetos);} /* if ((nplane==1) && (thisbar==15)) { nplane = 2; thisbar = 7;} if ((nplane==2) && (thisbar==12)) { nplane = 3; thisbar = 6;} if ((nplane==3) && (thisbar==11)) { nplane = 4; thisbar = 3;} if ((nplane==4) && (thisbar==7)) { nplane = 4; thisbar = 99;} */ } } TString canvasTotalSpinTest = "TotalSpinTest"; TString canvasTitleTotalSpinTest = "HAND - Total Spin (Not Scaled)"; TCanvas *totalSpinTestCanvas = new TCanvas(canvasTotalSpinTest,canvasTitleTotalSpinTest,1400,770); //x,y totalspintestpad01 = new TPad("totalspintestpad01","totalspintestpad01",0.0000,0.5000,0.5000,1.0000,0,0,0); totalspintestpad02 = new TPad("totalspintestpad02","totalspintestpad02",0.5000,0.5000,1.0000,1.0000,0,0,0); totalspintestpad03 = new TPad("totalspintestpad03","totalspintestpad03",0.0000,0.0000,1.0000,0.5000,0,0,0); totalspintestpad01->Draw(); totalspintestpad02->Draw(); totalspintestpad03->Draw(); totalspintestpad01->cd(); HANDTotalSpinUpx->SetTitle("Total Spin Up (Not Scaled)"); HANDTotalSpinUpx->Draw(); totalspintestpad01->Update(); totalspintestpad02->cd(); HANDTotalSpinDownx->SetTitle("Total Spin Down (Not Scaled)"); HANDTotalSpinDownx->Draw(); totalspintestpad02->Update(); totalspintestpad03->cd(); TF1 *fitasymtest = new TF1("fitasymtest","[0]",xBjmin,xBjmax); HANDAsymTest = HANDTotalSpinUpx->GetAsymmetry(HANDTotalSpinDownx); TString AsymTestTitle = "Target Asymmerty with Neutron Cuts vs. xBj for runs "; AsymTestTitle += HeRunNumber; AsymTestTitle += "-"; AsymTestTitle += endHeRunNumber; HANDAsymTest->SetTitle(AsymTestTitle); HANDAsymTest->Draw(); fitasymtest->SetLineColor(kBlue); HANDAsymTest->Fit("fitasymtest","R"); totalspintestpad03->Update(); TString asymTitle = "Target Asymmetry for Runs "; asymTitle += HeRunNumber; asymTitle += "-"; asymTitle += endHeRunNumber; TCanvas *asymCanvas = new TCanvas("asymCanvas",asymTitle,1400,770); //x,y asymCanvas->cd(); asymCanvas->SetGrid(); Double_t x[xBjbins], y[xBjbins], errorx[xBjbins], errory[xBjbins]; double minError; double maxError; double posStuff; double negStuff; double UpEvents; double DownEvents; asymOutFile << "Runs " << HeRunNumber << "-" << endHeRunNumber << endl; cout << "Runs " << HeRunNumber << "-" << endHeRunNumber << endl; asymOutFile << "xBj Asymmetry Stat. Error # Pos Events Pos Charge Pos LT # Neg Events Neg Charge Neg LT" << endl; cout << "xBj Asymmetry Stat. Error # Pos Events Pos Charge Pos LT # Neg Events Neg Charge Neg LT" << endl; for (int i=0; i<xBjbins; i++) { UpEvents = HANDTotalSpinUpx->GetBinContent(i); DownEvents = HANDTotalSpinDownx->GetBinContent(i); x[i] = HANDTotalSpinUpx->GetBinCenter(i); if (x[i] != (HANDTotalSpinDownx->GetBinCenter(i))) { cout << endl << endl << "!!!!!!!!!!!!!!!!!!!!!!!!!! STOP! THERE'S A PROBLEM!!!!!!!!!!!!!!!!!!!!!!" << endl << endl << endl;} posStuff = UpEvents/(HeChargeScaleUp * HelivetimeUp + 1e-15); negStuff = DownEvents/(HeChargeScaleDown * HelivetimeDown + 1e-15); y[i] = ((posStuff - negStuff)/(posStuff + negStuff + 1e-15)); errory[i] = 2*(DownEvents*sqrt(UpEvents) + UpEvents*sqrt(DownEvents))/((HeChargeScaleUp*HelivetimeUp)*(HeChargeScaleDown*HelivetimeDown)*pow((UpEvents/(HeChargeScaleUp*HelivetimeUp)) + (DownEvents/(HeChargeScaleDown*HelivetimeDown)),2) + 1e-15); if ((UpEvents == 0) || (DownEvents == 0)) { errory[i] = 1;} if ((UpEvents == 0) || (DownEvents == 0)) { y[i] = NULL;} if (i==0) { minError = y[i] - 2*errory[i]; maxError = y[i] + 2*errory[i]; } if ((y[i] - 2*errory[i]) < minError) { minError = y[i] - 2*errory[i];} if ((y[i] + 2*errory[i]) > maxError) { maxError = y[i] + 2*errory[i];} errorx[i] = ((xBjmax - xBjmin)/xBjbins)/2; asymOutFile << x[i] << " " << y[i] << " " << errory[i] << " " << UpEvents << " " << HeChargeScaleUp << " " << HelivetimeUp << " " << DownEvents << " " << HeChargeScaleDown << " " << HelivetimeDown << endl; cout << x[i] << " " << y[i] << " " << errory[i] << " " << UpEvents << " " << HeChargeScaleUp << " " << HelivetimeUp << " " << DownEvents << " " << HeChargeScaleDown << " " << HelivetimeDown << endl; } asymGraph = new TGraphErrors(xBjbins, x, y, errorx, errory); asymGraph->SetMarkerStyle(21); asymGraph->SetMarkerColor(4); asymGraph->SetTitle(asymTitle); asymTestHist = new TH2F("asymTestHist",asymTitle,xBjbins,xBjmin,xBjmax,100,minError,maxError); asymTestHist->SetStats(kFALSE); asymTestHist->Draw(); cout << "Fit min = " << xBjmin << "; Fit max = " << xBjmax << endl; TF1 *fitAsymGraph = new TF1("fitAsymGraph", "[0]", xBjmin, xBjmax); asymGraph->Draw("P"); fitAsymGraph->SetLineColor(kBlue); asymGraph->Fit("fitAsymGraph","R"); asymCanvas->Update(); TString TotalAsymOutTitle = outputPlotsHere; TotalAsymOutTitle += "target_asymmetry_good_for_Run_Num_"; TotalAsymOutTitle += HeRunNumber; TotalAsymOutTitle += "-"; TotalAsymOutTitle += endHeRunNumber; if (includeVetos) {TotalAsymOutTitle += "_with_vetos";} if (includeAntivetos) {TotalAsymOutTitle += "_with_antivetos";} if (antivetosAsVetos && includeAntivetos) {TotalAsymOutTitle += "_as_vetos";} TotalAsymOutTitle += ".png"; asymCanvas->Print(TotalAsymOutTitle); TString canvasTotalSpin = "TotalSpin"; TString canvasTitleTotalSpin = "HAND - Total Spin"; TCanvas *totalSpinCanvas = new TCanvas(canvasTotalSpin,canvasTitleTotalSpin,1400,770); //x,y totalspinpad01 = new TPad("totalspinpad01","totalspinpad01",0.0000,0.5000,0.5000,1.0000,0,0,0); totalspinpad02 = new TPad("totalspinpad02","totalspinpad02",0.5000,0.5000,1.0000,1.0000,0,0,0); totalspinpad03 = new TPad("totalspinpad03","totalspinpad03",0.0000,0.0000,1.0000,0.5000,0,0,0); totalspinpad01->Draw(); totalspinpad02->Draw(); totalspinpad03->Draw(); totalspinpad01->cd(); cout << "HeChargeScaleUp: " << HeChargeScaleUp << " HelivetimeUp: " << HelivetimeUp << endl; HANDTotalSpinUpx->Scale(1/(HeChargeScaleUp * HelivetimeUp)); HANDTotalSpinUpx->SetTitle("Total Spin Up (Scaled by Charge, LT)"); HANDTotalSpinUpx->Draw(); // ******************************************************************************** // This section below gathers and prints some statistics on the plot TString HANDUpFactorsString = "Total Positive Charge for Runs: "; HANDUpFactorsString += HeChargeScaleUp; HANDUpFactorsString += " C"; TString HANDUpFactorsString1 = "Total Positive Livetime for Runs: "; HANDUpFactorsString1 += HelivetimeUp; HANDUpFactors = new TPaveText(0.11,0.69,0.4,0.89,"NDC"); TText *t1 = HANDUpFactors->AddText(HANDUpFactorsString); TText *t2 = HANDUpFactors->AddText(HANDUpFactorsString1); HANDUpFactors->Draw("same"); // ******************************************************************************** totalspinpad01->Update(); totalspinpad02->cd(); cout << "HeChargeScaleDown: " << HeChargeScaleDown << " HelivetimeDown: " << HelivetimeDown << endl; HANDTotalSpinDownx->Scale(1/(HeChargeScaleDown * HelivetimeDown)); HANDTotalSpinDownx->SetTitle("Total Spin Down (Scaled by Charge, LT)"); HANDTotalSpinDownx->Draw(); // ******************************************************************************** // This section below gathers and prints some statistics on the plot TString HANDDownFactorsString = "Total Negative Charge for Runs: "; HANDDownFactorsString += HeChargeScaleDown; HANDDownFactorsString += " C"; TString HANDDownFactorsString1 = "Total Negative Livetime for Runs: "; HANDDownFactorsString1 += HelivetimeDown; HANDDownFactors = new TPaveText(0.11,0.69,0.4,0.89,"NDC"); TText *t1 = HANDDownFactors->AddText(HANDDownFactorsString); TText *t2 = HANDDownFactors->AddText(HANDDownFactorsString1); HANDDownFactors->Draw("same"); // ******************************************************************************** totalspinpad02->Update(); totalspinpad03->cd(); TF1 *fitasym = new TF1("fitasym","[0]",xBjmin,xBjmax); HANDAsym = HANDTotalSpinUpx->GetAsymmetry(HANDTotalSpinDownx); TString AsymTitle = "Target Asymmerty with Neutron Cuts vs. xBj for runs "; AsymTitle += HeRunNumber; AsymTitle += "-"; AsymTitle += endHeRunNumber; HANDAsym->SetTitle(AsymTitle); HANDAsym->Draw(); fitasym->SetLineColor(kBlue); HANDAsym->Fit("fitasym","R"); totalspinpad03->Update(); TString TotalSpinOutTitle = outputPlotsHere; TotalSpinOutTitle += "target_asymmetry_for_Run_Num_"; TotalSpinOutTitle += HeRunNumber; TotalSpinOutTitle += "-"; TotalSpinOutTitle += endHeRunNumber; if (includeVetos) {TotalSpinOutTitle += "_with_vetos";} if (includeAntivetos) {TotalSpinOutTitle += "_with_antivetos";} if (antivetosAsVetos && includeAntivetos) {TotalSpinOutTitle += "_as_vetos";} TotalSpinOutTitle += ".png"; totalSpinCanvas->Print(TotalSpinOutTitle); asymOutFile.close(); cout << "All done!" << endl; }
int main(int argc, char** argv) { //Check if all nedeed arguments to parse are there if(argc != 2) { std::cerr << ">>>>> VertexStudiesAnalysis::usage: " << argv[0] << " configFileName" << std::endl ; return 1; } // Parse the config file parseConfigFile (argv[1]) ; std::string inputFileList = gConfigParser -> readStringOption("Input::inputFileList"); std::string treeName = gConfigParser -> readStringOption("Input::treeName"); std::string outputRootFilePath = gConfigParser -> readStringOption("Output::outputRootFilePath"); std::string outputRootFileName = gConfigParser -> readStringOption("Output::outputRootFileName"); std::string tmvaMethod = gConfigParser -> readStringOption("Input::tmvaMethod"); std::string tmvaWeights = gConfigParser -> readStringOption("Input::tmvaWeights"); int entryMIN = gConfigParser -> readIntOption("Options::entryMIN"); int entryMAX = gConfigParser -> readIntOption("Options::entryMAX"); int isZee = gConfigParser -> readIntOption("Options::isZee"); int isZmumu = gConfigParser -> readIntOption("Options::isZmumu"); int isHiggs = gConfigParser -> readIntOption("Options::isHiggs"); int isData = gConfigParser -> readIntOption("Options::isData"); double trackThr = gConfigParser -> readDoubleOption("Options::trackThr"); int useWeights = gConfigParser -> readIntOption("Options::useWeights"); int poissonWeights = gConfigParser -> readIntOption("Options::poissonWeights"); int nAvePU = gConfigParser -> readIntOption("Options::nAvePU"); std::string puweightsFileName = gConfigParser -> readStringOption("Options::puweightsFileName"); int useJSON = gConfigParser -> readIntOption("Options::useJSON"); std::string jsonFileName = gConfigParser -> readStringOption("Options::jsonFileName"); //******* Get run/LS map from JSON file ******* std::map<int, std::vector<std::pair<int, int> > > jsonMap; if ( isData && useJSON ) { std::cout << ">>> Getting GOOD run/LS from JSON file" << std::endl; jsonMap = readJSONFile(jsonFileName); std::cout << std::endl; std::cout << std::endl; } //****** Get weights for MC ****** float nmax; float w[50]; TRandom *gRandom = new TRandom(); if (useWeights){ TFile weightsFile(puweightsFileName.c_str(),"READ"); TH1F* hweights; if ( poissonWeights ){ std::cout << "N ave PU for Poisson PU reweighting : " << nAvePU << std::endl; char hname[100]; sprintf(hname,"hwpoisson_%d",nAvePU); hweights = (TH1F*)weightsFile.Get(hname); } else { hweights = (TH1F*)weightsFile.Get("hweights"); } nmax = hweights ->GetMaximum(); std::cout << " Max weight " << nmax << std::endl; for (int ibin = 1; ibin < hweights->GetNbinsX()+1; ibin++){ w[ibin-1] = hweights->GetBinContent(ibin); // bin 1 --> nvtx = 0 } weightsFile.Close(); } //****** open TH1 with tracks pt for kolmogorov test TH1F *hTrackPt; TFile ptFile("hTracksPt_PU25_upTo10GeV.root","READ"); hTrackPt = (TH1F*)ptFile.Get("hTracksPt")->Clone("hTrackPt"); hTrackPt->SetDirectory(0); ptFile.Close(); std::cout << hTrackPt->GetEntries() << std::endl; TH1F *htemp = (TH1F*)hTrackPt->Clone("htemp"); htemp->Reset(); //****** Parameters for vertex finding algo ****** VertexAlgoParameters vtxAlgoParams_; vtxAlgoParams_.rescaleTkPtByError = false; vtxAlgoParams_.trackCountThr = 1.; vtxAlgoParams_.highPurityOnly = false; vtxAlgoParams_.maxD0Signif = 9999999.; vtxAlgoParams_.maxDzSignif = 9999999.; vtxAlgoParams_.removeTracksInCone = 1; vtxAlgoParams_.coneSize = 0.05; //--- sumpt2 ordering vector<string> ranksumpt2_; ranksumpt2_.push_back("logsumpt2"); //--- ranking product variables vector<string> rankVariables_; // variables order matters to resolve ties rankVariables_.push_back("ptbal"), rankVariables_.push_back("ptasym"),rankVariables_.push_back("logsumpt2"); //--- book TMVA int isSig, evtNumber, nVertices; float diphopt; float logsumpt2; float ptbal, ptasym, ptmax, ptmax3, sumpt, nchthr, nch, sumtwd; float dk; TMVA::Reader *tmvaReader_ = new TMVA::Reader( "!Color:!Silent" ); tmvaReader_->AddVariable( "logsumpt2",&logsumpt2 ); tmvaReader_->AddVariable( "ptbal" , &ptbal); tmvaReader_->AddVariable( "ptasym", &ptasym ); tmvaReader_->AddVariable( "nch",&nch ); tmvaReader_->AddVariable( "nchthr",&nchthr ); tmvaReader_->AddVariable( "ptmax" ,&ptmax ); tmvaReader_->AddVariable( "ptmax3",&ptmax3 ); tmvaReader_->AddVariable( "sumtwd",&sumtwd ); tmvaReader_->AddVariable( "dk",&dk ); tmvaReader_->BookMVA( tmvaMethod.c_str(), tmvaWeights.c_str() ); //****** BOOK OUTPUT HISTOGRAMS ****** TH1F PtAll("PtAll","Pt of boson all",80,0,400); TH1F PtGood("PtGood","Pt of boson good",80,0,400); TH1F PtGood_BDT("PtGood_BDT","Pt of boson good (BDT)",80,0,400); TH1F PtGood_RANK("PtGood_RANK","Pt of boson good (RANKING)",80,0,400); TH1F PtAll_EBEB("PtAll_EBEB","Pt of boson all",80,0,400); TH1F PtGood_EBEB("PtGood_EBEB","Pt of boson good",80,0,400); TH1F PtGood_BDT_EBEB("PtGood_BDT_EBEB","Pt of boson good (BDT)",80,0,400); TH1F PtGood_RANK_EBEB("PtGood_RANK_EBEB","Pt of boson good (RANKING)",80,0,400); TH1F PtAll_EBEE("PtAll_EBEE","Pt of boson all",80,0,400); TH1F PtGood_EBEE("PtGood_EBEE","Pt of boson good",80,0,400); TH1F PtGood_BDT_EBEE("PtGood_BDT_EBEE","Pt of boson good (BDT)",80,0,400); TH1F PtGood_RANK_EBEE("PtGood_RANK_EBEE","Pt of boson good (RANKING)",80,0,400); TH1F PtAll_EEEE("PtAll_EEEE","Pt of boson all",80,0,400); TH1F PtGood_EEEE("PtGood_EEEE","Pt of boson good",80,0,400); TH1F PtGood_BDT_EEEE("PtGood_BDT_EEEE","Pt of boson good (BDT)",80,0,400); TH1F PtGood_RANK_EEEE("PtGood_RANK_EEEE","Pt of boson good (RANKING)",80,0,400); TH1F EtaAll("EtaAll","Eta of max SC",50,-5,5); TH1F EtaGood("EtaGood","Eta of max SC good",50,-5,5); TH1F EtaGood_BDT("EtaGood_BDT","Eta of max SC good (BDT)",50,-5,5); TH1F EtaGood_RANK("EtaGood_RANK","Eta of max SC good (RANKING)",50,-5,5); TH1F NvtAll("NvtAll","number of PV all",50,0,50); TH1F NvtGood("NvtGood","number of PV good",50,0,50); TH1F NvtGood_BDT("NvtGood_BDT","number of PV good (BDT)",50,0,50); TH1F NvtGood_RANK("NvtGood_RANK","number of PV good (RANKING)",50,0,50); TH1F NpuAll("NpuAll","number of PV all",50,0,50); TH1F NpuGood("NpuGood","number of PV good",50,0,50); TH1F NpuGood_BDT("NpuGood_BDT","number of PV good (BDT)",50,0,50); TH1F NpuGood_RANK("NpuGood_RANK","number of PV good (RANKING)",50,0,50); TH1F PtGood_matchedClosest("PtGood_matchedClosest","Pt of boson good",80,0,400); TH1F PtGood_BDT_matchedClosest("PtGood_BDT_matchedClosest","Pt of boson good (BDT)",80,0,400); TH1F PtGood_RANK_matchedClosest("PtGood_RANK_matchedClosest","Pt of boson good (RANKING)",80,0,400); TH1F EtaGood_matchedClosest("EtaGood_matchedClosest","Eta of max SC good",50,-5,5); TH1F EtaGood_BDT_matchedClosest("EtaGood_BDT_matchedClosest","Eta of max SC good (BDT)",50,-5,5); TH1F EtaGood_RANK_matchedClosest("EtaGood_RANK_matchedClosest","Eta of max SC good (RANKING)",50,-5,5); TH1F NvtGood_matchedClosest("NvtGood_matchedClosest","number of PV good",50,0,50); TH1F NvtGood_BDT_matchedClosest("NvtGood_BDT_matchedClosest","number of PV good (BDT)",50,0,50); TH1F NvtGood_RANK_matchedClosest("NvtGood_RANK_matchedClosest","number of PV good (RANKING)",50,0,50); TH1F NpuGood_matchedClosest("NpuGood_matchedClosest","number of PV good",50,0,50); TH1F NpuGood_BDT_matchedClosest("NpuGood_BDT_matchedClosest","number of PV good (BDT)",50,0,50); TH1F NpuGood_RANK_matchedClosest("NpuGood_RANK_matchedClosest","number of PV good (RANKING)",50,0,50); TH2F hdist("hdist"," hdist",80,0,200,400,-10,10); TH2F hdiff_dZ_muons("hdiff_dZ_muons","hdiff_dZ_muons",80,0,200,400,-10,10); TH2F hdiff_dZ_electrons("hdiff_dZ_electrons","hdiff_dZ_electrons",80,0,200,400,-10,10); TH1F BDToutput("BDToutput","BDT output",500,-1,1); TH1F BDToutput_sig("BDToutput_sig","BDT output - signal vertices",500,-1,1); TH1F BDToutput_bkg("BDToutput_bkg","BDT output - background",500,-1,1); TH1F pt2h("pt2h","pt2 H",500,0,500); TH1F pt2bkg("pt2bkg","pt2 bkg",500,0,500); TH2F * hAcceptedLumis = new TH2F("hAcceptedLumis","hAcceptedLumis",20000, 160000, 180000, 10000, 0, 10000); float ww = 1; float r9cut = 0.93; //****** LOAD TREE ****** TChain* chain = new TChain(treeName.c_str()); FillChain(*chain, inputFileList.c_str()); treeReader reader((TTree*)(chain)); std::cout<<"found "<< reader.GetEntries() <<" entries"<<std::endl; //****** Start loop over entries ****** int runId, lumiId; for (int u = 0; u < reader.GetEntries(); u++ ) { if(u == entryMAX) break; if(u < entryMIN) continue; if(u%10000 == 0) std::cout<<"reading event "<< u <<std::endl; reader.GetEntry(u); //*** filter bad runs/lumis runId = reader.GetInt("runId")->at(0); lumiId = reader.GetInt("lumiId")->at(0); bool skipEvent = false; if( isData && useJSON ){ if(AcceptEventByRunAndLumiSection(runId,lumiId,jsonMap) == false) skipEvent = true; } if( skipEvent == true ) continue; hAcceptedLumis -> Fill(runId, lumiId); //*** pu weights std::vector<float>*PU_z ; std::vector<int>* mc_PUit_NumInteractions; int npu ; if ( !isData ){ mc_PUit_NumInteractions = reader.GetInt("mc_PUit_NumInteractions"); npu = mc_PUit_NumInteractions->at(0); //--- use weights if (useWeights){ float myrnd = gRandom->Uniform(0,nmax); if (myrnd > w[npu]) continue; } } //*** setup common branches *** std::vector<int>* PV_nTracks; std::vector<float>* PV_z; std::vector<float>* PV_d0; std::vector<ROOT::Math::XYZVector>* PVtracks; std::vector<int>* PVtracks_PVindex; std::vector<int>* tracks_PVindex; std::vector<float>* tracks_dz ; //? std::vector<float>* tracks_dz_PV ; //? std::vector<float>* tracks_dxy_PV ; //? std::vector<ROOT::Math::XYZTVector>* sc; // supercluster int accept = 0; int indpho1 = -100; int indpho2 = -100; ROOT::Math::XYZTVector sum2pho; float etaMaxSC ; float TrueVertex_Z; //*** selections for Hgg *** if (isHiggs){ std::vector<ROOT::Math::XYZVector>* mc_H_vertex = reader.Get3V("mc_H_vertex"); std::vector<ROOT::Math::XYZTVector>* mcV1 = reader.Get4V("mcV1"); std::vector<ROOT::Math::XYZTVector>* mcV2 = reader.Get4V("mcV2"); std::vector<ROOT::Math::XYZTVector>* photons = reader.Get4V("photons"); std::vector<float>* photons_r9 = reader.GetFloat("photons_r9"); if (mc_H_vertex->size() != 1) continue; PV_nTracks = reader.GetInt("PV_nTracks"); PV_z = reader.GetFloat("PV_z"); PV_d0 = reader.GetFloat("PV_d0"); PVtracks = reader.Get3V("PVtracks"); PVtracks_PVindex = reader.GetInt("PVtracks_PVindex"); tracks_PVindex = reader.GetInt("tracks_PVindex"); tracks_dxy_PV = reader.GetFloat("tracks_dxy_PV"); tracks_dz_PV = reader.GetFloat("tracks_dz_PV"); tracks_dz = reader.GetFloat("tracks_dz"); sc = reader.Get4V("photons_SC"); hggSelection(mcV1, mcV2, photons, sc, photons_r9, accept, indpho1, indpho2); if (!accept) continue; if ( photons_r9->at(indpho1) < r9cut ) continue; if ( photons_r9->at(indpho2) < r9cut ) continue; etaMaxSC = sc->at(indpho1).eta(); sum2pho = photons->at(indpho1)+ photons->at(indpho2); TrueVertex_Z = mc_H_vertex->at(0).Z(); }// end Hgg selection //*** selections for Zee *** if (isZee){ std::vector<ROOT::Math::XYZTVector>* electrons = reader.Get4V("electrons"); // std::vector<float>* eleid = reader.GetFloat("simpleEleId95cIso"); // no eleID95 available for data 2011 --> compute it by hand std::vector<float>* eleid = new std::vector<float>; eleid->clear(); if ( electrons->size() < 2) continue; for (unsigned int iele = 0; iele < electrons->size(); iele++){ float pt = electrons->at(iele).pt(); float tkIso = reader.GetFloat("electrons_tkIsoR03")->at(iele); float emIso = reader.GetFloat("electrons_emIsoR03")->at(iele); float hadIso = reader.GetFloat("electrons_hadIsoR03_depth1")->at(iele) + reader.GetFloat("electrons_hadIsoR03_depth2")->at(iele); float combIso = tkIso + emIso + hadIso; int isEB = reader.GetInt("electrons_isEB")->at(iele); float sigmaIetaIeta = reader.GetFloat("electrons_sigmaIetaIeta")->at(iele); float DetaIn = reader.GetFloat("electrons_deltaEtaIn")->at(iele); float DphiIn = reader.GetFloat("electrons_deltaPhiIn")->at(iele); float HOverE = reader.GetFloat("electrons_hOverE")->at(iele); int mishits = reader.GetInt("electrons_mishits")->at(iele); float id = eleId95 ( pt, tkIso, emIso, hadIso, combIso, isEB, sigmaIetaIeta, DetaIn, DphiIn, HOverE, mishits); id *= 7.; // to emulate simpleEleId95cIso eleid->push_back( id ); } std::vector<float>* electrons_dz_PV_noEle = reader.GetFloat("electrons_dz_PV_noEle"); PV_nTracks = reader.GetInt("PV_noEle_nTracks"); PV_z = reader.GetFloat("PV_noEle_z"); PV_d0 = reader.GetFloat("PV_noEle_d0"); PVtracks = reader.Get3V("PVEleLessTracks"); PVtracks_PVindex = reader.GetInt("PVEleLessTracks_PVindex"); tracks_PVindex = reader.GetInt("tracks_PVindex"); tracks_dxy_PV = reader.GetFloat("tracks_dxy_PV"); tracks_dz_PV = reader.GetFloat("tracks_dz_PV"); tracks_dz = reader.GetFloat("tracks_dz"); //sc = reader.Get4V("electrons_SC"); sc = reader.Get4V("electrons"); zeeSelection(electrons, eleid, accept, indpho1, indpho2); if (!accept) continue; etaMaxSC = sc->at(indpho1).eta(); sum2pho = electrons->at(indpho1)+ electrons->at(indpho2); TrueVertex_Z = PV_z->at(0) + (electrons_dz_PV_noEle->at(indpho1) + electrons_dz_PV_noEle->at(indpho2))/2.; hdiff_dZ_electrons.Fill( sum2pho.pt(), electrons_dz_PV_noEle->at(indpho1) - electrons_dz_PV_noEle->at(indpho2) ); } //*** selections for Zmumu if ( isZmumu ){ std::vector<ROOT::Math::XYZTVector>* muons = reader.Get4V("muons"); std::vector<int>* muons_global = reader.GetInt("muons_global"); std::vector<int>* muons_tracker = reader.GetInt("muons_tracker"); std::vector<float>* muons_tkIsoR03 = reader.GetFloat("muons_tkIsoR03"); std::vector<float>* muons_normalizedChi2 = reader.GetFloat("muons_normalizedChi2"); std::vector<int>* muons_numberOfValidMuonHits = reader.GetInt("muons_numberOfValidMuonHits"); std::vector<int>* muons_numberOfValidPixelHits = reader.GetInt("muons_numberOfValidPixelHits"); std::vector<float>* muons_dxy_PV = reader.GetFloat("muons_dxy_PV"); std::vector<float>* muons_dz_PV = reader.GetFloat("muons_dz_PV"); std::vector<float>* muons_dz_PV_noMuon = reader.GetFloat("muons_dz_PV_noMuon"); PV_nTracks = reader.GetInt("PV_noMuon_nTracks"); PV_z = reader.GetFloat("PV_noMuon_z"); PV_d0 = reader.GetFloat("PV_noMuon_d0"); PVtracks = reader.Get3V("PVMuonLessTracks"); PVtracks_PVindex = reader.GetInt("PVMuonLessTracks_PVindex"); tracks_PVindex = reader.GetInt("tracks_PVindex"); tracks_dxy_PV = reader.GetFloat("tracks_dxy_PV"); tracks_dz_PV = reader.GetFloat("tracks_dz_PV"); tracks_dz = reader.GetFloat("tracks_dz"); sc = reader.Get4V("muons"); // use muon info for SC zmumuSelection(muons,muons_global,muons_tracker, muons_tkIsoR03, muons_normalizedChi2 , muons_numberOfValidMuonHits, muons_numberOfValidPixelHits, muons_dxy_PV, muons_dz_PV, accept, indpho1, indpho2); if (!accept) continue; etaMaxSC = muons->at(indpho1).eta(); sum2pho = muons->at(indpho1)+ muons->at(indpho2); TrueVertex_Z = PV_z->at(0) + (muons_dz_PV_noMuon->at(indpho1) + muons_dz_PV_noMuon->at(indpho2))/2.; hdiff_dZ_muons.Fill( sum2pho.pt(), muons_dz_PV_noMuon->at(indpho1) - muons_dz_PV_noMuon->at(indpho2) ); if ( fabs(muons_dz_PV_noMuon->at(indpho1) - muons_dz_PV_noMuon->at(indpho2))> 0.5) continue; }//Zmumu end // branches buffers int nvtx_; float vtxx_[1000], vtxy_[1000], vtxz_[1000]; int ntracks_; float tkpx_[1000], tkpy_[1000], tkpz_[1000], tkPtErr_[1000], tkWeight_[1000], tkd0_[1000], tkd0Err_[1000], tkdz_[1000], tkdzErr_[1000]; int tkVtxId_[1000]; bool tkIsHighPurity_[1000]; float phocalox_[100], phocaloy_[100], phocaloz_[100], phoen_[100]; // set variables // vertices nvtx_ = (int) PV_z->size(); for ( int iv = 0; iv < nvtx_; iv++){ vtxx_[iv] = 0; vtxy_[iv] = 0; vtxz_[iv] = PV_z->at(iv) ; } // tracks ntracks_ = PVtracks->size(); for (int itrk = 0; itrk <ntracks_; itrk++ ){ tkpx_[itrk] = PVtracks->at(itrk).X(); tkpy_[itrk] = PVtracks->at(itrk).Y(); tkpz_[itrk] = PVtracks->at(itrk).Z(); tkPtErr_[itrk] = 0; tkVtxId_[itrk] = PVtracks_PVindex->at(itrk); tkWeight_[itrk]= 1.; tkd0_[itrk] = 0; tkd0Err_[itrk] = 0; tkdz_[itrk] = 0; tkdzErr_[itrk] = 0; tkIsHighPurity_[itrk]= 1.; } // photons for (int ipho = 0 ; ipho < sc->size(); ipho++){ float px = sc->at(ipho).X(); float py = sc->at(ipho).Y(); float pz = sc->at(ipho).Z(); float pt = sqrt ( px*px+py*py ); float theta = 2*atan(exp(-sc->at(ipho).eta()) ); float tantheta = tan(theta); if ( fabs(sc->at(ipho).eta()) < etaEB ) { phocalox_[ipho] = R_ECAL*px/pt; phocaloy_[ipho] = R_ECAL*py/pt; phocaloz_[ipho] = R_ECAL/tantheta; } if ( fabs(sc->at(ipho).eta()) > etaEE ) { float r_endcap = fabs(Z_ENDCAP * tantheta); phocalox_[ipho] = r_endcap * px/pt; phocaloy_[ipho] = r_endcap * py/pt; if (pz > 0) phocaloz_[ipho] = Z_ENDCAP; else phocaloz_[ipho] = -Z_ENDCAP; } phoen_[ipho] = sc->at(ipho).E(); } float eta1 = sc->at(indpho1).eta(); float eta2 = sc->at(indpho2).eta(); if ( (fabs(eta1) > etaEB && fabs(eta1) < etaEE) || fabs(eta1) > 2.5) continue; if ( (fabs(eta2) > etaEB && fabs(eta2) < etaEE) || fabs(eta2) > 2.5) continue; //*** set vertex info TupleVertexInfo vinfo( nvtx_, vtxx_ , vtxy_, vtxz_, ntracks_, tkpx_, tkpy_, tkpz_, tkPtErr_, tkVtxId_, tkWeight_, tkd0_, tkd0Err_,tkdz_, tkdzErr_ , tkIsHighPurity_); //*** set photon info PhotonInfo pho1(indpho1, TVector3(phocalox_[indpho1],phocaloy_[indpho1],phocaloz_[indpho1]),phoen_[indpho1]); PhotonInfo pho2(indpho2, TVector3(phocalox_[indpho2],phocaloy_[indpho2],phocaloz_[indpho2]),phoen_[indpho2]); //*** vertex analyzer HggVertexAnalyzer vAna(vtxAlgoParams_,nvtx_); vAna.analyze(vinfo,pho1,pho2); // if Zmumu : setNconv to zero if (isZmumu) vAna.setNConv(0); //*** preselect vertices std::vector<int> presel; for(int i=0; i<nvtx_; i++) { presel.push_back(i); } vAna.preselection(presel); //*** Look if the H vertex matches one of the PV vertices float dmin = 10000; int iClosest = -1; for ( int uu = 0; uu < nvtx_; uu++){ float distt = fabs( PV_z->at(uu) - TrueVertex_Z ); if ( distt < dmin) { dmin = distt; iClosest = uu; } } //*** NOW FILL HISTOGRAMS PtAll.Fill( sum2pho.pt(),ww ); if (fabs(eta1) < etaEB && fabs(eta2) < etaEB) PtAll_EBEB.Fill( sum2pho.pt(),ww ); if (fabs(eta1) > etaEE && fabs(eta2) > etaEE) PtAll_EEEE.Fill( sum2pho.pt(),ww ); if ( (fabs(eta1) < etaEB && fabs(eta2) > etaEE) || (fabs(eta2) < etaEB && fabs(eta1) > etaEE)) PtAll_EBEE.Fill( sum2pho.pt(),ww ); EtaAll.Fill( etaMaxSC ,ww); NvtAll.Fill( nvtx_,ww ); if (!isData) NpuAll.Fill(npu,ww); //*** SUMPT2 CRITERION vector<int> ranksumpt2 = vAna.rankprod(ranksumpt2_); //-- matching 1cm if ( fabs( TrueVertex_Z - PV_z->at(ranksumpt2[0]) ) < 1.) { PtGood.Fill( sum2pho.pt(),ww ); EtaGood.Fill( etaMaxSC ,ww); NvtGood.Fill( nvtx_ ,ww); if (!isData) NpuGood.Fill(npu,ww); } //-- matching closest vtx if ( iClosest == ranksumpt2[0]){ PtGood_matchedClosest.Fill( sum2pho.pt(),ww ); EtaGood_matchedClosest.Fill( etaMaxSC ,ww); NvtGood_matchedClosest.Fill( nvtx_ ,ww); if (!isData) NpuGood_matchedClosest.Fill(npu,ww); } //*** RANKING PRODUCT vector<int> rankprod = vAna.rankprod(rankVariables_); //-- matching 1cm if ( fabs( TrueVertex_Z - PV_z->at(rankprod[0]) ) < 1.) { PtGood_RANK.Fill( sum2pho.pt(),ww ); EtaGood_RANK.Fill( etaMaxSC ,ww); NvtGood_RANK.Fill( nvtx_,ww ); if (!isData) NpuGood_RANK.Fill(npu,ww); } //-- matching closest vtx if ( iClosest == rankprod[0]){ PtGood_RANK_matchedClosest.Fill( sum2pho.pt(),ww ); EtaGood_RANK_matchedClosest.Fill( etaMaxSC ,ww); NvtGood_RANK_matchedClosest.Fill( nvtx_,ww ); if (!isData) NpuGood_RANK_matchedClosest.Fill(npu,ww); } //*** BDT int TMVAind = -1; float TMVAmax = -1000.; for ( int uu = 0; uu < nvtx_; uu++){ diphopt = vAna.diphopt(uu); logsumpt2 = vAna.logsumpt2(uu); nch = vAna.nch(uu); nchthr = vAna.nchthr(uu); ptbal = vAna.ptbal(uu); ptasym = vAna.ptasym(uu); ptmax = vAna.ptmax(uu); ptmax3 = vAna.ptmax3(uu); sumtwd = vAna.sumtwd(uu); htemp->Reset(); for (unsigned int kk = 0; kk < PVtracks->size(); ++kk){ if (PVtracks_PVindex->at(kk) == uu){ float tkpt = sqrt(PVtracks->at(kk).perp2()) ; htemp ->Fill( (tkpt < 10. ? tkpt : 10.) ); } } if ( htemp->GetEntries()!=0 ) dk = htemp->KolmogorovTest(hTrackPt); //--- Evaluate TMVA Double_t mva = tmvaReader_->EvaluateMVA( "BDTG" ); BDToutput.Fill( mva ); if ( fabs( TrueVertex_Z - PV_z->at(uu) ) < 1.) BDToutput_sig.Fill( mva ); else BDToutput_bkg.Fill( mva ); // take the highest score if ( mva > TMVAmax) { TMVAmax = mva; TMVAind = uu; } } // end loop over vertices //-- matching 1cm if ( fabs( TrueVertex_Z - PV_z->at(TMVAind) ) < 1.) { PtGood_BDT.Fill( sum2pho.pt(),ww ); EtaGood_BDT.Fill( etaMaxSC ,ww); NvtGood_BDT.Fill( nvtx_ ,ww); if (!isData) NpuGood_BDT.Fill(npu,ww); } //-- matching closest vtx if ( iClosest == TMVAind){ PtGood_BDT_matchedClosest.Fill( sum2pho.pt(),ww ); EtaGood_BDT_matchedClosest.Fill( etaMaxSC ,ww); NvtGood_BDT_matchedClosest.Fill( nvtx_,ww ); if (!isData) NpuGood_BDT_matchedClosest.Fill(npu,ww); } }// end loop over entries std::cout << "END LOOP OVER ENTRIES" << std::endl; std::cout << "Saving histos on file ..." << std::endl; TFile ff( (outputRootFilePath+outputRootFileName).c_str(),"recreate"); hAcceptedLumis -> Write(); PtAll.Write(); PtGood.Write(); PtGood_BDT.Write(); PtGood_RANK.Write(); EtaAll.Write(); EtaGood.Write(); EtaGood_BDT.Write(); EtaGood_RANK.Write(); NvtAll.Write(); NvtGood.Write(); NvtGood_BDT.Write(); NvtGood_RANK.Write(); NpuAll.Write(); NpuGood.Write(); NpuGood_BDT.Write(); NpuGood_RANK.Write(); PtGood_matchedClosest.Write(); PtGood_BDT_matchedClosest.Write(); PtGood_RANK_matchedClosest.Write(); EtaGood_matchedClosest.Write(); EtaGood_BDT_matchedClosest.Write(); EtaGood_RANK_matchedClosest.Write(); NvtGood_matchedClosest.Write(); NvtGood_BDT_matchedClosest.Write(); NvtGood_RANK_matchedClosest.Write(); NpuGood_matchedClosest.Write(); NpuGood_BDT_matchedClosest.Write(); NpuGood_RANK_matchedClosest.Write(); hdist.Write(); hdiff_dZ_muons.Write(); hdiff_dZ_electrons.Write(); BDToutput.Write(); BDToutput_sig.Write(); BDToutput_bkg.Write(); ff.Close(); std::cout << "BYE BYE !!!! " << std::endl; return 0; }
int main() { float lumi = 2260.; TString dir = "/Users/dygyun/Top/HET_v763"; //TString dir = "/xrootd/store/user/tjkim/ntuples/hep/V6"; TFile * fA = TFile::Open(dir+"/hep_TT_powheg.root"); TFile * fB = TFile::Open(dir+"/hep_TT_powheg.root"); TFile * fC = TFile::Open(dir+"/hep_WJets.root"); TFile * fD = TFile::Open(dir+"/hep_DYJets.root"); TFile * fE = TFile::Open(dir+"/hep_DYJets_10to50.root"); TFile * fI = TFile::Open(dir+"/hep_SingleTop_t.root"); TFile * fJ = TFile::Open(dir+"/hep_SingleTbar_t.root"); TFile * fK = TFile::Open(dir+"/hep_SingleTop_tW.root"); TFile * fL = TFile::Open(dir+"/hep_SingleTbar_tW.root"); TFile * fN = TFile::Open(dir+"/hep_WW.root"); TFile * fO = TFile::Open(dir+"/hep_WZ.root"); TFile * fM = TFile::Open(dir+"/hep_ZZ.root"); // TFile * fP = TFile::Open(dir+"/hep_qcd.root"); TH1F * hBsemi = (TH1F*) fA->Get("TopTree/EventSummary"); TH1F * hB = (TH1F*) fB->Get("TopTree/EventSummary"); TH1F * hC = (TH1F*) fC->Get("TopTree/EventSummary"); TH1F * hD = (TH1F*) fD->Get("TopTree/EventSummary"); TH1F * hE = (TH1F*) fE->Get("TopTree/EventSummary"); TH1F * hI = (TH1F*) fI->Get("TopTree/EventSummary"); TH1F * hJ = (TH1F*) fJ->Get("TopTree/EventSummary"); TH1F * hK = (TH1F*) fK->Get("TopTree/EventSummary"); TH1F * hL = (TH1F*) fL->Get("TopTree/EventSummary"); TH1F * hN = (TH1F*) fN->Get("TopTree/EventSummary"); TH1F * hO = (TH1F*) fO->Get("TopTree/EventSummary"); TH1F * hM = (TH1F*) fM->Get("TopTree/EventSummary"); // TH1F * hP = (TH1F*) fP->Get(""); int nevt = -1; MyAnalysis *A = new MyAnalysis(); TChain* ch = new TChain("TopTree/events"); ch->Add(Form("%s/hep_data_json.root",dir.Data()), nevt); ch->Process(A); MyAnalysis_others *B = new MyAnalysis_others(1,1,831.8,lumi,hB->GetBinContent(1)); TChain* ch2 = new TChain("TopTree/events"); ch2->Add(Form("%s/hep_TT_powheg.root",dir.Data()), nevt); ch2->Process(B); ////// MyAnalysis_Sig *Bsemi = new MyAnalysis_Sig(1,1,831.8,lumi,hBsemi->GetBinContent(1)); TChain* ch2semi = new TChain("TopTree/events"); ch2semi->Add(Form("%s/hep_TT_powheg.root",dir.Data()), nevt); ch2semi->Process(Bsemi); ///////// MyAnalysis *C = new MyAnalysis(1,1,61524,lumi,hC->GetBinContent(2)); TChain* ch3 = new TChain("TopTree/events"); ch3->Add(Form("%s/hep_WJets.root",dir.Data()),nevt); ch3->Process(C); MyAnalysis *D = new MyAnalysis(1,1,6025.2,lumi,hD->GetBinContent(1)); TChain* ch4 = new TChain("TopTree/events"); ch4->Add(Form("%s/hep_DYJets.root",dir.Data()),nevt); ch4->Process(D); MyAnalysis *E = new MyAnalysis(1,1,18610.0,lumi,hE->GetBinContent(1)); TChain* ch5 = new TChain("TopTree/events"); ch5->Add(Form("%s/hep_DYJets_10to50.root",dir.Data()),nevt); ch5->Process(E); MyAnalysis *I = new MyAnalysis(1,1,44.33,lumi,hI->GetBinContent(1)); TChain* ch6 = new TChain("TopTree/events"); ch6->Add(Form("%s/hep_SingleTop_t.root",dir.Data()),nevt); ch6->Process(I); MyAnalysis *J = new MyAnalysis(1,1,26.38,lumi,hJ->GetBinContent(1)); TChain* ch7 = new TChain("TopTree/events"); ch7->Add(Form("%s/hep_SingleTbar_t.root",dir.Data()),nevt); ch7->Process(J); MyAnalysis *K = new MyAnalysis(1,1,35.6,lumi,hK->GetBinContent(1)); TChain* ch8 = new TChain("TopTree/events"); ch8->Add(Form("%s/hep_SingleTop_tW.root",dir.Data()),nevt); ch8->Process(K); MyAnalysis *L = new MyAnalysis(1,1,35.6,lumi,hL->GetBinContent(1)); TChain* ch9 = new TChain("TopTree/events"); ch9->Add(Form("%s/hep_SingleTbar_tW.root",dir.Data()),nevt); ch9->Process(L); MyAnalysis *N = new MyAnalysis(1,1,118.7,lumi,hN->GetBinContent(1)); TChain* ch10 = new TChain("TopTree/events"); ch10->Add(Form("%s/hep_WW.root",dir.Data()),nevt); ch10->Process(N); MyAnalysis *O = new MyAnalysis(1,1,47.13,lumi,hO->GetBinContent(1)); TChain* ch11 = new TChain("TopTree/events"); ch11->Add(Form("%s/hep_WZ.root",dir.Data()),nevt); ch11->Process(O); MyAnalysis *M = new MyAnalysis(1,1,16.523,lumi,hM->GetBinContent(1)); TChain* ch12 = new TChain("TopTree/events"); ch12->Add(Form("%s/hep_ZZ.root",dir.Data()),nevt); ch12->Process(M); Plotter P; for (int i=0; i < 6 ;i++) { //for (int i=0; i < D->histograms.size() ;i++) { //merge for DY D->histograms[i]->Add(E->histograms[i]); //merge for SingleTop I->histograms[i]->Add(J->histograms[i]); I->histograms[i]->Add(K->histograms[i]); I->histograms[i]->Add(L->histograms[i]); //////merge for VV N->histograms[i]->Add(O->histograms[i]); N->histograms[i]->Add(M->histograms[i]); ////tt bkg // B->histograms[i]->Add(Bhad->histograms[i]); } P.SetData(A->histograms, std::string("Data")); P.AddBg(Bsemi->histograms, std::string("TTbar")); P.AddBg(C->histograms, std::string("Wjets")); P.AddBg(D->histograms, std::string("DY")); P.AddBg(I->histograms, std::string("Single Top")); P.AddBg(N->histograms, std::string("VV")); P.AddBg(B->histograms, std::string("TTOthers")); P.Plot(string("results_ABCD.pdf")); TFile * outA = TFile::Open("hist_data.root","RECREATE"); for(int i=0; i < A->histograms.size(); i++){ TH1F * tmp = (TH1F *) A->histograms[i]; tmp->Write(); } for(int i=0; i < A->histograms_2D.size(); i++){ TH2D * tmp = (TH2D *) A->histograms_2D[i]; tmp->Write(); } outA->Write(); outA->Close(); TFile * outB = TFile::Open("hist_TT_others.root","RECREATE"); for(int i=0; i < B->histograms.size(); i++){ TH1F * tmp = (TH1F *) B->histograms[i]; tmp->Write(); } for(int i=0; i < B->histograms_2D.size(); i++){ TH2D * tmp = (TH2D *) B->histograms_2D[i]; tmp->Write(); } outB->Write(); outB->Close(); TFile * outBsemi = TFile::Open("hist_TT_SemiLeptonic.root","RECREATE"); for(int i=0; i < Bsemi->histograms.size(); i++){ TH1F * tmp = (TH1F *) Bsemi->histograms[i]; tmp->Write(); } for(int i=0; i < Bsemi->histograms_2D.size(); i++){ TH2D * tmp = (TH2D *) Bsemi->histograms_2D[i]; tmp->Write(); } outBsemi->Write(); outBsemi->Close(); TFile * outC = TFile::Open("hist_WJets.root","RECREATE"); for(int i=0; i < C->histograms.size(); i++){ TH1F * tmp = (TH1F *) C->histograms[i]; tmp->Write(); } for(int i=0; i < C->histograms_2D.size(); i++){ TH2D * tmp = (TH2D *) C->histograms_2D[i]; tmp->Write(); } outC->Write(); outC->Close(); TFile * outD = TFile::Open("hist_DY.root","RECREATE"); for(int i=0; i < D->histograms.size(); i++){ TH1F * tmp = (TH1F *) D->histograms[i]; tmp->Write(); } for(int i=0; i < D->histograms_2D.size(); i++){ TH2D * tmp = (TH2D *) D->histograms_2D[i]; tmp->Write(); } outD->Write(); outD->Close(); TFile * outI = TFile::Open("hist_SingleTop.root","RECREATE"); for(int i=0; i < I->histograms.size(); i++){ TH1F * tmp = (TH1F *) I->histograms[i]; tmp->Write(); } for(int i=0; i < I->histograms_2D.size(); i++){ TH2D * tmp = (TH2D *) I->histograms_2D[i]; tmp->Write(); } outI->Write(); outI->Close(); TFile * outN = TFile::Open("hist_VV.root","RECREATE"); for(int i=0; i < N->histograms.size(); i++){ TH1F * tmp = (TH1F *) N->histograms[i]; tmp->Write(); } for(int i=0; i < N->histograms_2D.size(); i++){ TH2D * tmp = (TH2D *) N->histograms_2D[i]; tmp->Write(); } outN->Write(); outN->Close(); }
void TP_eff_mu(TString fileName = "SingleMuon_Run2016_TP", // RooT file with TP otree for data TString what = "IdIso", //what do you want to evaluated float iso = 0.1, //isolation cut to be used float norm = 1 // luminosity normalization factor (1 for data) ) { gErrorIgnoreLevel = kFatal; // output inizialization TString lepton = "Muon"; TString OutFileName = fileName + "_" + lepton + "_" + what + "_IsoLt" + Form("%.2f", iso) + "_eff_Spring16"; TFile * outputFile = new TFile(OutFileName+".root","recreate"); // Title of axis in plots TString yTitle = "Efficiency"; TString xTitle = lepton+" p_{T}[GeV]"; TString xtit; xtit = "m_{#mu#mu}[GeV]"; //names of final graphs - suffix bool isData=false; if (fileName.Contains("SingleMuon")) isData = true; TString SampleName("_MC"); if (isData) SampleName = "_Data"; //open input file TFile * file = new TFile(fileName+".root"); file->cd(); TTree *t = (TTree*)(file->Get("TagProbe")); //binning inizialization int nEtaBins = 3; float etaBins[4] = {0,0.9,1.2,2.1}; TString EtaBins[3] = {"EtaLt0p9", "Eta0p9to1p2", "EtaGt1p2"}; float ptBins_def[8] = {10,15,20,25,30,40,60,1000}; TString PtBins_def[7] = {"Pt10to15", "Pt15to20", "Pt20to25", "Pt25to30", "Pt30to40", "Pt40to60", "PtGt60"}; float ptBinsTrig_def[17] = {10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 45, 50, 60, 70, 100, 1000}; TString PtBinsTrig_def[16] = {"Pt10to13", "Pt13to16", "Pt16to19", "Pt19to22", "Pt22to25", "Pt25to28", "Pt28to31", "Pt31to34", "Pt34to37", "Pt37to40", "Pt40to45", "Pt45to50", "Pt50to60", "Pt60to70", "Pt70to100", "PtGt100"}; int nPtBins = 16; if(what == "IdIso") nPtBins = 7; float * ptBins = new float[nPtBins+1]; TString * PtBins = new TString[nPtBins]; if(what == "IdIso"){ for(int i=0; i<nPtBins; ++i){ ptBins[i] = ptBins_def[i]; PtBins[i] = PtBins_def [i]; } ptBins[nPtBins] = ptBins_def[nPtBins]; } else { for(int i=0; i<nPtBins; ++i){ ptBins[i] = ptBinsTrig_def[i]; PtBins[i] = PtBinsTrig_def[i]; } ptBins[nPtBins] = ptBinsTrig_def[nPtBins]; } // create eta histogram with eta ranges associated to their names (eg. endcap, barrel) ***** // TH1D * etaBinsH = new TH1D("etaBinsH", "etaBinsH", nEtaBins, etaBins); etaBinsH->Draw(); etaBinsH->GetXaxis()->Set(nEtaBins, etaBins); for (int i=0; i<nEtaBins; i++){ etaBinsH->GetXaxis()->SetBinLabel(i+1, EtaBins[i]);} etaBinsH->Draw(); // create pt histogram_s with pt ranges associated to their names (eg. Pt10to13, ..) ***** // TH1D * ptBinsH = new TH1D("ptBinsH", "ptBinsH", nPtBins, ptBins); ptBinsH->Draw(); ptBinsH->GetXaxis()->Set(nPtBins, ptBins); for (int i=0; i<nPtBins; i++){ ptBinsH->GetXaxis()->SetBinLabel(i+1, PtBins[i]);} ptBinsH->Draw(); float ptBins_edges[nPtBins+1]; for (int i=0; i<nPtBins; i++) { ptBins_edges[i]=ptBinsH->GetBinLowEdge(i+1); } ptBins_edges[nPtBins]= ptBinsH->GetBinLowEdge(nPtBins+1); // define if in the fit of failing probes // the FSR component will be used in the // signal function bool fitWithFSR[nPtBins]; for (int i=0; i<nPtBins; i++) fitWithFSR[i] = true; if(what == "IdIso"){ fitWithFSR[0]=false; fitWithFSR[1]=false; fitWithFSR[5]=false; fitWithFSR[6]=false; } else{ for (int i=0; i<nPtBins; i++) fitWithFSR[i] = false; } // building the histogram base name TString prefix = "ZMass"; TString which = what; if (what == "IdIso") which = ""; which = ""; TString histBaseName; //definition of the passing and failing criterias TCut cut_flag_idiso_pass, cut_flag_hlt_pass, cut_flag_hlt_fail, cut_pt, cut_eta; if (what == "IdIso") { cut_flag_idiso_pass = Form("id_probe == 1 && iso_probe < %f", iso); } else{ if(what == "hlt_1") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_1_probe == 0"; } if(what == "hlt_2") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_2_probe == 0"; } if(what == "hlt_3") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_3_probe == 0"; } if(what == "hlt_4") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_4_probe == 0"; } if(what == "hlt_5") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_5_probe == 0"; } if(what == "hlt_6") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_6_probe == 0"; } if(what == "hlt_7") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_7_probe == 0"; } if(what == "hlt_8") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_8_probe == 0"; } if(what == "hlt_9") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_9_probe == 0"; } if(what == "hlt_10") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_10_probe == 0"; } if(what == "hlt_11") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_11_probe == 0"; } if(what == "hlt_12") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_12_probe == 0"; } if(what == "hlt_13") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_13_probe == 0"; } if(what == "hlt_14") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_14_probe == 0"; } if(what == "hlt_15") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_15_probe == 0"; } if(what == "hlt_16") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_16_probe == 0"; } if(what == "hlt_17") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_17_probe == 0"; } if(what == "hlt_18") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_18_probe == 0"; } if(what == "hlt_19") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_19_probe == 0"; } if(what == "hlt_20") {cut_flag_hlt_pass = "******"; cut_flag_hlt_fail = "hlt_20_probe == 0"; } } //Definition of the output directory names and creation of it TString dir_name = "Muon_"; dir_name += what; dir_name += Form("_IsoLt%.2f", iso); if (!isData) dir_name += "_MC"; dir_name += "_eff"; gSystem->mkdir(dir_name, kTRUE); for (int iEta = 0; iEta < nEtaBins; iEta++) { //loop on eta bins histBaseName = prefix+which+EtaBins[iEta]; //eta cuts cut_eta = Form("abs(eta_probe)>= %f && abs(eta_probe)< %f", etaBins[iEta], etaBins[iEta+1]); TH1F * numeratorH = new TH1F("numeratorH","",nPtBins,ptBins_edges); TH1F * denominatorH = new TH1F("denominatorH","",nPtBins,ptBins_edges); for (int iPt=0; iPt<nPtBins; ++iPt) { //loop on pt bins //pt cuts cut_pt = Form("pt_probe > %f && pt_probe < %f", ptBins[iPt], ptBins[iPt+1]); TH1F * histPassOld = new TH1F("histPassOld","",250,50,300); TH1F * histFailOld = new TH1F("histFailOld","",250,50,300); //Drawing histogram of passing and failing probes if (what == "IdIso") { t->Draw("m_vis>>histPassOld", "pu_weight*mcweight" + (cut_eta && cut_pt && cut_flag_idiso_pass)); t->Draw("m_vis>>histFailOld", "pu_weight*mcweight" + (cut_eta && cut_pt && !cut_flag_idiso_pass)); }else{ t->Draw("m_vis>>histPassOld", "pu_weight*mcweight" + (cut_eta && cut_pt && cut_flag_hlt_pass && cut_flag_idiso_pass)); t->Draw("m_vis>>histFailOld", "pu_weight*mcweight" + (cut_eta && cut_pt && cut_flag_hlt_fail && cut_flag_idiso_pass)); } int nBinsX = histPassOld->GetNbinsX(); //lumi renormalization for (int iB=1;iB<=nBinsX;++iB) { histPassOld->SetBinContent(iB,norm*histPassOld->GetBinContent(iB)); histPassOld->SetBinError(iB,norm*histPassOld->GetBinError(iB)); histFailOld->SetBinContent(iB,norm*histFailOld->GetBinContent(iB)); histFailOld->SetBinError(iB,norm*histFailOld->GetBinError(iB)); } float output[2]; TCanvas * c1 = new TCanvas("c1","",700,600); TCanvas * c2 = new TCanvas("c2","",700,600); //defining fit options bool fitPass = true; bool fitFail = true; bool rebinPass = false; bool rebinFail = false; if(what != "IdIso") {fitPass= false; fitFail = false;} //fitting FitPassAndFail(fileName, histBaseName+PtBins[iPt], xtit, histPassOld, histFailOld, fitPass, fitFail, fitWithFSR[iPt], rebinPass, rebinFail, c1, c2, output, dir_name); c1->cd(); c1->Update(); c2->cd(); c2->Update(); numeratorH->SetBinContent(iPt+1,output[0]); denominatorH->SetBinContent(iPt+1,output[0]+output[1]); } outputFile->cd(); //produce efficiencies plot TGraphAsymmErrors * eff = new TGraphAsymmErrors(); eff->Divide(numeratorH,denominatorH); eff->GetXaxis()->SetTitle(xTitle); // eff->GetXaxis()->SetRangeUser(10.01,59.99); eff->GetYaxis()->SetRangeUser(0,1.0); eff->GetXaxis()->SetRangeUser(0,99.99); eff->GetYaxis()->SetTitle(yTitle); eff->GetXaxis()->SetTitleOffset(1.1); eff->GetXaxis()->SetNdivisions(510); eff->GetYaxis()->SetTitleOffset(1.1); eff->SetMarkerStyle(21); eff->SetMarkerSize(1); eff->SetMarkerColor(kBlue); eff->SetLineWidth(2); eff->SetLineColor(kBlue); if(!isData){ eff->SetMarkerColor(kRed); eff->SetLineColor(kRed); } TCanvas * canv = new TCanvas("canv","",700,600); eff->Draw("APE"); canv->SetGridx(); canv->SetGridy(); canv->Update(); canv->SaveAs(dir_name + "/" + fileName+"_" + histBaseName + ".png"); eff->Write(histBaseName+SampleName); /* for(int ip=0; ip<nPtBins; ++ip){ cout<<"PtBins "<<ip<<" content: "<<numeratorH->GetBinContent(ip)/ denominatorH->GetBinContent(ip)<<endl; }*/ } //closing outputFile->cd(); etaBinsH->Write(); outputFile->Close(); }
void calccorr(int i=1,string t="ptfiner"){ float const PI = acos(-1.0); if(i==0){ const int ncent = 6; const int npt = 25; TString dire="north"; } else if(i==1){ const int ncent = 6; const int npt = 25; TString dire="south"; } else if(i==2){ const int ncent = 6; const int npt = 1; TString dire="sn"; } TFile *f=TFile::Open("../../../work/20GeV/output_3corrF.root"); TH1F* kforebbcw[ncent][npt]; TH1F* hforebbcw[ncent][npt]; TH1F* kbackbbcw2[ncent][npt]; TH1F* kforebbcw_In; TH1F* hforebbcw_In; TH1F* kbackbbcw2_In; double ptbin[26] = {0,0.2,0.4,0.6,0.8,1.0,1.2,1.4,1.6,1.8,2.0,2.2,2.4,2.6,2.8,3.0,3.2,3.4,3.6,3.8,4.0,4.2,4.4,4.6,4.8,5.0}; double centbin[7] = {0,0.05,0.1,0.2,0.4,0.6,1.0}; //double centbin[ncent+1] = {0,1,2}; TString type = t.c_str(); if(type=="ptIn25_4"){ double selptbin[] = {2.5,4.0}; double selcentbin[ncent+1] = {0,0.01,0.05,0.1,0.2,0.3,0.4,0.6,1.0}; } else if(type=="ptIn"){ if(i==2){ double selptbin[] = {0.0,0.2}; } else{ double selptbin[] = {0.4,3.0}; } double selcentbin[] = {0,0.05,0.1,0.2,0.4,0.6,1.0}; } else if(type=="ptcoarser"){ double selptbin[] = {0.2,1.0,2.0,3.0,5.0}; double selcentbin[] = {0,0.01,0.05,0.1,0.2,0.3,0.4,0.6,1.0}; } else if(type=="ptfiner"){ double selptbin[] = {0.2,0.4,0.6,0.8,1.0,1.2,1.4,1.6,1.8,2.0,2.2,2.4,2.6,2.8,3.0,3.2,3.4,3.6,3.8,4.0,4.2,4.4,4.6,4.8,5.0}; double selcentbin[] = {0,0.05,0.1,0.2,0.4,0.6,1.0}; //double selcentbin[ncent+1] = {0,1,2}; } else if(type=="centIn"){ double selptbin[] = {0.2,0.5,1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0}; double selcentbin[] = {0,1.0}; } else if(type=="ptccentc"){ double selptbin[] = {0.2,0.4,0.6,0.8,1.0,1.2,1.4,1.6,1.8,2.0,2.2,2.4,2.6,2.8,3.0,3.2,3.4,3.6,3.8,4.0,4.2,4.4,4.6,4.8,5.0}; double selcentbin[] = {0,0.1}; } else{exit(0);}; /*double ptmin = 1.0; double ptmax = 3.0;//has to be boundary for(int ipt=0; ipt<npt; ipt++){ if(ptmin >= ptbin[ipt] && ptmin < ptbin[ipt+1]){int xptmin = ipt; continue;} if(ptmax >= ptbin[ipt] && ptmax < ptbin[ipt+1]){int xptmax = ipt; continue;} }*/ ofstream fout(Form("c1_c2_central_%s_%s.dat",type.Data(),dire.Data())); for(int icent=0; icent<ncent; icent++){ for(int ipt=0; ipt<npt; ipt++){ kforebbcw[icent][ipt] = (TH1F*)f->Get(Form("kfore%sbbcw_%d_%d",dire.Data(),icent,ipt)); //htemp = (TH1F*)f->Get(Form("kforenorthbbcw_%d_%d",icent,ipt)); //kforebbcw[icent][ipt]->Add(htemp,-1); hforebbcw[icent][ipt] = (TH1F*)f->Get(Form("hfore%sbbcw_%d_%d",dire.Data(),icent,ipt)); //htemp = (TH1F*)f->Get(Form("hforenorthbbcw_%d_%d",icent,ipt)); //hforebbcw[icent][ipt]->Add(htemp,-1); kbackbbcw2[icent][ipt] = (TH1F*)f->Get(Form("kback%sbbcw2_%d_%d",dire.Data(),icent,ipt)); //htemp = (TH1F*)f->Get(Form("kbacknorthbbcw2_%d_%d",icent,ipt)); //kbackbbcw2[icent][ipt]->Add(htemp,-1); } } int ncent_a = sizeof(selcentbin)/sizeof(double)-1; int npt_a = sizeof(selptbin)/sizeof(double)-1; for(int icent_a=0;icent_a<ncent+1;icent_a++){ for(int icent_b=0; icent_b<ncent+1; icent_b++) if(selcentbin[icent_a] == centbin[icent_b]) break; int xcentmin = icent_b; for(int icent_b=0; icent_b<ncent+1; icent_b++) if(selcentbin[icent_a+1] == centbin[icent_b]) break; int xcentmax = icent_b; if((xcentmin == ncent+1) || (xcentmax == ncent+1)) exit(0); for(int ipt_a=0;ipt_a<npt_a;ipt_a++){ for(int ipt_b=0; ipt_b<npt+1; ipt_b++) if(selptbin[ipt_a] == ptbin[ipt_b]) break; int xptmin = ipt_b; for(int ipt_b=0; ipt_b<npt+1; ipt_b++) if(selptbin[ipt_a+1] == ptbin[ipt_b]) break; int xptmax = ipt_b; if((xptmin == npt+1) || (xptmax == npt+1)) exit(0); cout<<xcentmin<<"\t"<<xcentmax<<"\t"<<endl; cout<<xptmin<<"\t"<<xptmax<<"\t"<<endl; kforebbcw_In = (TH1F*)kforebbcw[xcentmin][xptmin]->Clone(); hforebbcw_In = (TH1F*)hforebbcw[xcentmin][xptmin]->Clone(); kbackbbcw2_In = (TH1F*)kbackbbcw2[xcentmin][xptmin]->Clone(); kforebbcw_In->Reset(); hforebbcw_In->Reset(); kbackbbcw2_In->Reset(); for(int icent=xcentmin; icent<xcentmax; icent++){ for(int ipt=xptmin; ipt<xptmax; ipt++){ kforebbcw_In->Add(kforebbcw[icent][ipt]); hforebbcw_In->Add(hforebbcw[icent][ipt]); kbackbbcw2_In->Add(kbackbbcw2[icent][ipt]); } } kforebbcw_In->Rebin(2); hforebbcw_In->Rebin(2); kbackbbcw2_In->Rebin(2); TH1F* hpp; TH1F* hbackpp; hpp = (TH1F*)kforebbcw_In->Clone(); hbackpp = (TH1F*)kbackbbcw2_In->Clone(); float nbackpp = hbackpp->Integral()/2.0/PI; float nforepp = hpp->Integral()/2.0/PI; //float ntrig0 = ptforedis_0->Integral(11,30); for(int i=0; i<20; i++){ float pp_cont = 1.0*hpp->GetBinContent(i+1); //float pp0_err = 1.0*hpp->GetBinError(i+1); float weight2 = sqrt(1.0*hforebbcw_In->GetBinContent(i+1)); float backpp_cont = 1.0*hbackpp->GetBinContent(i+1); float con = pp_cont/backpp_cont*nbackpp/nforepp; float err = weight2/backpp_cont*nbackpp/nforepp; hpp->SetBinContent(i+1, con); hpp->SetBinError(i+1, err); } TF1 *fun0 = new TF1("fun0","[0]*(1+2*[1]*cos(x)+2*[2]*cos(2*x)+2*[3]*cos(3*x)+2*[4]*cos(4*x))", -0.5*PI, 1.5*PI); fun0->SetLineColor(1); hpp->Fit("fun0","NORQ"); TF1 *fun1 = new TF1("fun1","[0]*(1+2*[1]*cos(x))", -0.5*PI, 1.5*PI); TF1 *fun2 = new TF1("fun2","[0]*(1+2*[1]*cos(2*x))", -0.5*PI, 1.5*PI); TF1 *fun3 = new TF1("fun3","[0]*(1+2*[1]*cos(3*x))", -0.5*PI, 1.5*PI); TF1 *fun4 = new TF1("fun4","[0]*(1+2*[1]*cos(4*x))", -0.5*PI, 1.5*PI); //const double ptmean[npt] = {0.360943, 0.691833, 1.1911, 1.69654, 2.20117, 2.70571, 3.2097, 3.71372, 4.21814, 4.72014}; fout<<fun0->GetParameter(1)<<" "<<fun0->GetParError(1)<<" " <<fun0->GetParameter(2)<<" "<<fun0->GetParError(2)<<" "//<<0.05*fun0->GetParameter(2)<<" "<<endl; <<fun0->GetParameter(3)<<" "<<fun0->GetParError(3)<<endl; } } fout.close(); /* cout<<"*************** v2 ***********"<<endl; float v2_0 = funvn0->GetParameter(1)/(zym_pp0 + funvn0->GetParameter(0)); float v2_1 = funvn1->GetParameter(1)/(zym_pp1 + funvn1->GetParameter(0)); float v2_2 = funvn2->GetParameter(1)/(zym_pp2 + funvn2->GetParameter(0)); float v2_3 = funvn3->GetParameter(1)/(zym_pp3 + funvn3->GetParameter(0)); cout<<v2_0<<" "<<v2_1<<" "<<v2_2<<" "<<v2_3<<endl; cout<<funvn0->GetParameter(0)*funvn0->GetParameter(1)<<" " <<funvn1->GetParameter(0)*funvn1->GetParameter(1)<<" " <<funvn2->GetParameter(0)*funvn2->GetParameter(1)<<" " <<funvn3->GetParameter(0)*funvn3->GetParameter(1)<<endl; cout<<"*************** v2 ***********"<<endl; cout<<funvn0->GetParameter(2)<<" "<<funvn1->GetParameter(2)<<" "<<funvn2->GetParameter(2)<<" "<<funvn3->GetParameter(2)<<endl; cout<<"*************** v3 ***********"<<endl; cout<<funvn0->GetParameter(3)<<" "<<funvn1->GetParameter(3)<<" "<<funvn2->GetParameter(3)<<" "<<funvn3->GetParameter(3)<<endl; */ }
void cutFlowStudyMu( TString weightFile = "TMVAClassificationPtOrd_qqH115vsWZttQCD_Cuts.weights.xml", Double_t effS_ = 0.3) { ofstream out("cutFlow-MuTauStream.txt"); out.precision(4); TMVA::Tools::Instance(); TMVA::Reader *reader = new TMVA::Reader( "!Color:!Silent" ); Float_t pt1, pt2; Float_t Deta, Mjj; Float_t eta1,eta2; reader->AddVariable( "pt1", &pt1); reader->AddVariable( "pt2", &pt2); reader->AddVariable( "Deta",&Deta); reader->AddVariable( "Mjj", &Mjj); reader->AddSpectator("eta1",&eta1); reader->AddSpectator("eta2",&eta2); reader->BookMVA( "Cuts", TString("/home/llr/cms/lbianchini/CMSSW_3_9_9/src/Bianchi/TauTauStudies/test/Macro/weights/")+weightFile ); TFile *fFullSignalVBF = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_VBFH115-Mu-powheg-PUS1.root","READ"); TFile *fFullSignalGGH = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_GGFH115-Mu-powheg-PUS1.root","READ"); TFile *fFullBackgroundDYTauTau = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_DYToTauTau-Mu-20-PUS1.root","READ"); TFile *fFullBackgroundDYMuMu = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_DYToMuMu-20-PUS1.root","READ"); TFile *fFullBackgroundWJets = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_WJets-Mu-madgraph-PUS1.root","READ"); TFile *fFullBackgroundQCD = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_QCDmu.root","READ"); TFile *fFullBackgroundTTbar = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_TTJets-Mu-madgraph-PUS1.root","READ"); TFile *fFullBackgroundDiBoson = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_DiBoson-Mu.root","READ"); // OpenNTuples TString fSignalNameVBF = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleVBFH115-Mu-powheg-PUS1_Open_MuTauStream.root"; TString fSignalNameGGH = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleGGFH115-Mu-powheg-PUS1_Open_MuTauStream.root"; TString fBackgroundNameDYTauTau = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleDYToTauTau-Mu-20-PUS1_Open_MuTauStream.root"; TString fBackgroundNameDYMuMu = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleDYToMuMu-20-PUS1_Open_MuTauStream.root"; TString fBackgroundNameWJets = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleWJets-Mu-madgraph-PUS1_Open_MuTauStream.root"; TString fBackgroundNameQCD = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleQCDmu_Open_MuTauStream.root"; TString fBackgroundNameTTbar = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleTTJets-Mu-madgraph-PUS1_Open_MuTauStream.root"; TString fBackgroundNameDiBoson = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleDiBoson-Mu_Open_MuTauStream.root"; TFile *fSignalVBF(0); TFile *fSignalGGH(0); TFile *fBackgroundDYTauTau(0); TFile *fBackgroundDYMuMu(0); TFile *fBackgroundWJets(0); TFile *fBackgroundQCD(0); TFile *fBackgroundTTbar(0); TFile *fBackgroundDiBoson(0); fSignalVBF = TFile::Open( fSignalNameVBF ); fSignalGGH = TFile::Open( fSignalNameGGH ); fBackgroundDYTauTau = TFile::Open( fBackgroundNameDYTauTau ); fBackgroundDYMuMu = TFile::Open( fBackgroundNameDYMuMu ); fBackgroundWJets = TFile::Open( fBackgroundNameWJets ); fBackgroundQCD = TFile::Open( fBackgroundNameQCD ); fBackgroundTTbar = TFile::Open( fBackgroundNameTTbar ); fBackgroundDiBoson = TFile::Open( fBackgroundNameDiBoson ); if(!fSignalVBF || !fBackgroundDYTauTau || !fBackgroundWJets || !fBackgroundQCD || !fBackgroundTTbar || !fSignalGGH || !fBackgroundDYMuMu || !fBackgroundDiBoson ){ std::cout << "ERROR: could not open files" << std::endl; exit(1); } TString tree = "outTreePtOrd"; TTree *signalVBF = (TTree*)fSignalVBF->Get(tree); TTree *signalGGH = (TTree*)fSignalGGH->Get(tree); TTree *backgroundDYTauTau = (TTree*)fBackgroundDYTauTau->Get(tree); TTree *backgroundDYMuMu = (TTree*)fBackgroundDYMuMu->Get(tree); TTree *backgroundWJets = (TTree*)fBackgroundWJets->Get(tree); TTree *backgroundQCD = (TTree*)fBackgroundQCD->Get(tree); TTree *backgroundTTbar = (TTree*)fBackgroundTTbar->Get(tree); TTree *backgroundDiBoson = (TTree*)fBackgroundDiBoson->Get(tree); // here I define the map between a sample name and its tree std::map<std::string,TTree*> tMap; tMap["ggH115"]=signalGGH; tMap["qqH115"]=signalVBF; tMap["Ztautau"]=backgroundDYTauTau; tMap["Zmumu"]=backgroundDYMuMu; tMap["Wjets"]=backgroundWJets; tMap["QCD"]=backgroundQCD; tMap["TTbar"]=backgroundTTbar; tMap["DiBoson"]=backgroundDiBoson; std::map<std::string,TTree*>::iterator jt; Float_t pt1_, pt2_; Float_t Deta_, Mjj_; Float_t Dphi,diTauSVFitPt,diTauSVFitEta,diTauVisMass,diTauSVFitMass,ptL1,ptL2,etaL1,etaL2,diTauCharge,MtLeg1,numPV,combRelIsoLeg1,sampleWeight,ptVeto,HLT; Int_t tightestHPSWP; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// // here I choose the order in the stack std::vector<string> samples; samples.push_back("ggH115"); samples.push_back("qqH115"); samples.push_back("DiBoson"); samples.push_back("TTbar"); samples.push_back("Wjets"); samples.push_back("Zmumu"); samples.push_back("Ztautau"); samples.push_back("QCD"); std::map<std::string,float> crossSec; crossSec["ggH115"]=( 7.65e-02 * 18.13 ); crossSec["qqH115"]=( 0.1012); crossSec["DiBoson"]=( -1 ); crossSec["TTbar"]=( 157.5 ); crossSec["Wjets"]=( 31314.0); crossSec["Zmumu"]=( 1666 ); crossSec["Ztautau"]=( 1666 ); crossSec["QCD"]=( 296600000*0.0002855 ); float Lumi = 1000; // here I choose the order in the stack std::vector<string> filters; filters.push_back("total"); filters.push_back("vertex"); filters.push_back("1-mu"); filters.push_back("0-e"); filters.push_back("mu-ID"); filters.push_back("tau-ID"); filters.push_back("Delta R mu-tau"); filters.push_back("mu-iso"); filters.push_back("tau-iso"); filters.push_back("Mt"); filters.push_back("OS"); filters.push_back("2-jets"); filters.push_back("VBF cuts"); filters.push_back("jet-veto"); filters.push_back("HLT"); // here I define the map between a sample name and its file ptr std::map<std::string,TFile*> fullMap; fullMap["ggH115"] = fFullSignalGGH; fullMap["qqH115"] = fFullSignalVBF; fullMap["Ztautau"] = fFullBackgroundDYTauTau; fullMap["Zmumu"] = fFullBackgroundDYMuMu; fullMap["Wjets"] = fFullBackgroundWJets; fullMap["QCD"] = fFullBackgroundQCD; fullMap["TTbar"] = fFullBackgroundTTbar; fullMap["DiBoson"] = fFullBackgroundDiBoson; std::map<std::string,TFile*>::iterator it; std::map<std::string,float> cutMap_allEventsFilter; std::map<std::string,float> cutMap_allEventsFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); float tot = totalEvents; if(crossSec[it->first]>0) tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; cutMap_allEventsFilter[it->first] = tot; cutMap_allEventsFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_vertexScrapingFilter; std::map<std::string,float> cutMap_vertexScrapingFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("vertexScrapingFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_vertexScrapingFilter[it->first] = tot; cutMap_vertexScrapingFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_oneElectronFilter; std::map<std::string,float> cutMap_oneElectronFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("oneMuonFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_oneElectronFilter[it->first] = tot; cutMap_oneElectronFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_noMuonFilter; std::map<std::string,float> cutMap_noMuonFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("noElecFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_noMuonFilter[it->first] = tot; cutMap_noMuonFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_electronLegFilter; std::map<std::string,float> cutMap_electronLegFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("muonLegFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_electronLegFilter[it->first] = tot; cutMap_electronLegFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_tauLegFilter; std::map<std::string,float> cutMap_tauLegFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("tauLegFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_tauLegFilter[it->first] = tot; cutMap_tauLegFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_atLeastOneDiTauFilter; std::map<std::string,float> cutMap_atLeastOneDiTauFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("atLeastOneDiTauFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_atLeastOneDiTauFilter[it->first] = tot; cutMap_atLeastOneDiTauFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_ElecIso; std::map<std::string,float> cutMap_ElecIsoE; for(it = fullMap.begin(); it != fullMap.end(); it++){ cout<<it->first<<endl; TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); TH1F* h1 = new TH1F("h1","",1,-10,10); TCut cut = (crossSec[it->first]>0) ? "(chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1" : "weight*((chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1)"; ((TTree*) (it->second->Get("muTauStreamAnalyzer/tree")) )->Draw("diTauLegsP4[0].Eta()>>h1",cut); float tot = h1->Integral(); float totalEquivalentEvents = h1->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_ElecIso[it->first] = tot; cutMap_ElecIsoE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; delete h1; } std::map<std::string,float> cutMap_TauIso; std::map<std::string,float> cutMap_TauIsoE; for(it = fullMap.begin(); it != fullMap.end(); it++){ cout<<it->first<<endl; TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); TH1F* h1 = new TH1F("h1","",1,-10,10); TCut cut = (crossSec[it->first]>0) ? "(chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0" : "weight*((chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0)"; ((TTree*) (it->second->Get("muTauStreamAnalyzer/tree")) )->Draw("diTauLegsP4[0].Eta()>>h1",cut); float tot = h1->Integral(); float totalEquivalentEvents = h1->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_TauIso[it->first] = tot; cutMap_TauIsoE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; delete h1; } std::map<std::string,float> cutMap_Mt; std::map<std::string,float> cutMap_MtE; for(it = fullMap.begin(); it != fullMap.end(); it++){ cout<<it->first<<endl; TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); TH1F* h1 = new TH1F("h1","",1,-10,10); TCut cut = (crossSec[it->first]>0) ? "(chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0 && MtLeg1<40" : "weight*((chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0 && MtLeg1<40)"; ((TTree*) (it->second->Get("muTauStreamAnalyzer/tree")) )->Draw("diTauLegsP4[0].Eta()>>h1",cut); float tot = h1->Integral(); float totalEquivalentEvents = h1->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_Mt[it->first] = tot; cutMap_MtE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; delete h1; } std::map<std::string,float> cutMap_OS; std::map<std::string,float> cutMap_OSE; for(it = fullMap.begin(); it != fullMap.end(); it++){ cout<<it->first<<endl; TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); TH1F* h1 = new TH1F("h1","",1,-10,10); TCut cut = (crossSec[it->first]>0) ? "(chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0 && diTauCharge==0 && MtLeg1<40" : "weight*((chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0 && diTauCharge==0 && MtLeg1<40)"; ((TTree*) (it->second->Get("muTauStreamAnalyzer/tree")) )->Draw("diTauLegsP4[0].Eta()>>h1",cut); float tot = h1->Integral(); float totalEquivalentEvents = h1->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_OS[it->first] = tot; cutMap_OSE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; delete h1; } std::map<std::string,float> cutMap_VBFPre; std::map<std::string,float> cutMap_VBFPreE; for(jt = tMap.begin(); jt != tMap.end(); jt++){ cout<<jt->first<<endl; TH1F* h1 = new TH1F("h1","",1,-10,10); TCut cut = "sampleWeight*(pt1>0 && combRelIsoLeg1<0.1 && tightestHPSWP>0 && diTauCharge==0 && MtLeg1<40)"; jt->second->Draw("etaL1>>h1",cut); float tot = h1->Integral(); float totalEquivalentEvents = h1->GetEffectiveEntries(); cutMap_VBFPre[jt->first] = tot; cutMap_VBFPreE[jt->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; delete h1; } std::map<std::string,float> cutMap_VBF; std::map<std::string,float> cutMap_VBFE; std::map<std::string,float> cutMap_JetVeto; std::map<std::string,float> cutMap_JetVetoE; std::map<std::string,float> cutMap_HLT; std::map<std::string,float> cutMap_HLTE; for(jt = tMap.begin(); jt != tMap.end(); jt++){ cout<<jt->first<<endl; TCut cut = "(pt1>0 && combRelIsoLeg1<0.1 && tightestHPSWP>0 && diTauCharge==0 && MtLeg1<40)"; TFile* dummy = new TFile("dummy.root","RECREATE"); TTree* currentTree = (TTree*)(jt->second)->CopyTree(cut); float tot = 0; int counter = 0; float tot2 = 0; int counter2 = 0; float tot3 = 0; int counter3 = 0; currentTree->SetBranchAddress( "pt1", &pt1_ ); currentTree->SetBranchAddress( "pt2", &pt2_ ); currentTree->SetBranchAddress( "Deta",&Deta_ ); currentTree->SetBranchAddress( "Mjj", &Mjj_ ); currentTree->SetBranchAddress( "diTauSVFitPt",&diTauSVFitPt); //currentTree->SetBranchAddress( "diTauSVFitEta",&diTauSVFitEta); currentTree->SetBranchAddress( "diTauSVFitMass",&diTauSVFitMass); currentTree->SetBranchAddress( "diTauVisMass",&diTauVisMass); currentTree->SetBranchAddress( "ptL1", &ptL1 ); currentTree->SetBranchAddress( "ptL2", &ptL2 ); currentTree->SetBranchAddress( "etaL1", &etaL1 ); currentTree->SetBranchAddress( "etaL2", &etaL2 ); currentTree->SetBranchAddress( "combRelIsoLeg1",&combRelIsoLeg1); currentTree->SetBranchAddress( "tightestHPSWP",&tightestHPSWP); currentTree->SetBranchAddress( "diTauCharge",&diTauCharge); currentTree->SetBranchAddress( "MtLeg1",&MtLeg1); currentTree->SetBranchAddress( "numPV",&numPV); currentTree->SetBranchAddress( "sampleWeight",&sampleWeight); currentTree->SetBranchAddress( "ptVeto",&ptVeto); currentTree->SetBranchAddress( "HLT",&HLT); for (Long64_t ievt=0; ievt<currentTree->GetEntries();ievt++) { currentTree->GetEntry(ievt); if (ievt%10000 == 0){ std::cout << (jt->first) << " ---> processing event: " << ievt << " ..." <<std::endl; } pt1 = pt1_; pt2 = pt2_; Deta = Deta_; Mjj = Mjj_; bool pass = effS_>0 ? reader->EvaluateMVA( "Cuts", effS_ ) : (pt1>0); if(pass){ tot+=sampleWeight; counter++; if(ptVeto<20){ tot2+=sampleWeight; counter2++; if(HLT>0.5 && HLT<1.5){ tot3+=sampleWeight; counter3++; } } } }// end loop cutMap_VBF[jt->first] = tot; cutMap_VBFE[jt->first] = counter>0 ? sqrt(counter)*tot/counter : 0; cutMap_JetVeto[jt->first] = tot2; cutMap_JetVetoE[jt->first] = counter2>0 ? sqrt(counter2)*tot2/counter2 : 0; cutMap_HLT[jt->first] = tot3; cutMap_HLTE[jt->first] = counter3>0 ? sqrt(counter3)*tot3/counter3 : 0; } std::vector< std::map<std::string,float> > allFilters; allFilters.push_back(cutMap_allEventsFilter); allFilters.push_back(cutMap_vertexScrapingFilter); allFilters.push_back(cutMap_oneElectronFilter); allFilters.push_back(cutMap_noMuonFilter); allFilters.push_back(cutMap_electronLegFilter); allFilters.push_back(cutMap_tauLegFilter); allFilters.push_back(cutMap_atLeastOneDiTauFilter); allFilters.push_back(cutMap_ElecIso); allFilters.push_back(cutMap_TauIso); allFilters.push_back(cutMap_Mt); allFilters.push_back(cutMap_OS); allFilters.push_back(cutMap_VBFPre); allFilters.push_back(cutMap_VBF); allFilters.push_back(cutMap_JetVeto); allFilters.push_back(cutMap_HLT); std::vector< std::map<std::string,float> > allFiltersE; allFiltersE.push_back(cutMap_allEventsFilterE); allFiltersE.push_back(cutMap_vertexScrapingFilterE); allFiltersE.push_back(cutMap_oneElectronFilterE); allFiltersE.push_back(cutMap_noMuonFilterE); allFiltersE.push_back(cutMap_electronLegFilterE); allFiltersE.push_back(cutMap_tauLegFilterE); allFiltersE.push_back(cutMap_atLeastOneDiTauFilterE); allFiltersE.push_back(cutMap_ElecIsoE); allFiltersE.push_back(cutMap_TauIsoE); allFiltersE.push_back(cutMap_MtE); allFiltersE.push_back(cutMap_OSE); allFiltersE.push_back(cutMap_VBFPreE); allFiltersE.push_back(cutMap_VBFE); allFiltersE.push_back(cutMap_JetVetoE); allFiltersE.push_back(cutMap_HLTE); //out<<"\\begin{center}"<<endl; out<<"\\begin{tabular}[!htbp]{|c"; for(int k = 0 ; k < samples.size(); k++) out<<"|c"; out<<"|} \\hline"<<endl; out<< "Cut & "; for(int k = 0 ; k < samples.size(); k++){ out << (fullMap.find(samples[k]))->first; if(k!=samples.size()-1) out <<" & " ; else out << " \\\\ " << endl; } out << " \\hline" << endl; for(int i = 0; i < allFilters.size(); i++){ out << filters[i] << " & "; for(int k = 0 ; k < samples.size(); k++){ out << (allFilters[i].find(samples[k]))->second << " $\\pm$ " << (allFiltersE[i].find(samples[k]))->second; if(k!=samples.size()-1) out <<" & " ; else out << " \\\\ " << endl; } out << " \\hline" << endl; } out<<"\\end{tabular}"<<endl; //out<<"\\end{center}"<<endl; return; }
int main(int argc, char* argv[]){ TH1::AddDirectory(0); ModTDRStyle(); string cfg; // The configuration file bool do_ratio = false; bool do_logy = true; vector<string> datacards; string fitresult_file = ""; string parse_rule = ""; string output = ""; string text1 = ""; string text2 = ""; bool blinded = true; bool postfit = true; po::variables_map vm; po::options_description config("configuration"); config.add_options() ("help,h", "print the help message") ("datacards,d", po::value<vector<string>> (&datacards)->multitoken()->required()) ("fitresult,f", po::value<string> (&fitresult_file)) ("parse_rule,p", po::value<string> (&parse_rule) ->default_value("$MASS/$ANALYSIS_$CHANNEL_$BINID_$ERA.txt")) ("output", po::value<string>(&output)->required(), "[REQUIRED] output name (no extension)") ("text1", po::value<string>(&text1)->default_value(""), "[REQUIRED] output name (no extension)") ("text2", po::value<string>(&text2)->default_value(""), "[REQUIRED] output name (no extension)") ("blinded", po::value<bool>(&blinded)->default_value("true"), "[REQUIRED] blinded") ("postfit", po::value<bool>(&postfit)->required(), "[REQUIRED] use the pulls file to make a post-fit plot"); po::store(po::command_line_parser(argc, argv) .options(config).allow_unregistered().run(), vm); po::notify(vm); ch::CombineHarvester cmb; // cmb.SetVerbosity(2); for (auto const& d : datacards) { cmb.ParseDatacard(d, parse_rule); } ch::SetStandardBinNames(cmb); RooFitResult* fitresult = nullptr; if (fitresult_file.length() && postfit) { fitresult = new RooFitResult(ch::OpenFromTFile<RooFitResult>(fitresult_file)); auto fitparams = ch::ExtractFitParameters(*fitresult); cmb.UpdateParameters(fitparams); } auto bins = cmb.bin_set(); TH1F proto("proto", "proto", 17, -3, 0.4); for (auto const& bin : bins) { ch::CombineHarvester cmb_bin = std::move(cmb.cp().bin({bin})); TH1F bkg = cmb_bin.cp().backgrounds().GetShape(); TH1F sig = cmb_bin.cp().signals().GetShape(); std::map<int, int> bin_mapping; for (int b = 1; b <= bkg.GetNbinsX(); ++b) { float i_sig = sig.GetBinContent(b); float i_bkg = bkg.GetBinContent(b); int bin_result = 1; if (i_sig > 0.) { float s_sb = i_sig / (i_sig + i_bkg); bin_result = proto.FindFixBin(std::log10(s_sb)); if (bin_result == 0) { bin_result = 1; } else if (bin_result == 16) { std::cout << "Bin " << bin << " has an s/s+b == 1\n"; } else if (bin_result == 18) { std::cout << "Bin " << bin << " has an s/s+b: " << s_sb << "\n"; std::cout << "Bin " << bin << " has s: " << i_sig << "\n"; std::cout << "Bin " << bin << " has b: " << i_bkg << "\n"; } } bin_mapping[b] = bin_result; } cmb_bin.ForEachObs([&](ch::Observation *e) { TH1 const* old_h = e->shape(); std::unique_ptr<TH1> new_h = ch::make_unique<TH1F>(TH1F(proto)); for (int b = 1; b <= old_h->GetNbinsX(); ++b) { int new_bin = (bin_mapping.find(b))->second; new_h->SetBinContent( new_bin, new_h->GetBinContent(new_bin) + old_h->GetBinContent(b)); } e->set_shape(std::move(new_h), false); }); cmb_bin.ForEachProc([&](ch::Process *e) { TH1 const* old_h = e->shape(); std::unique_ptr<TH1> new_h = ch::make_unique<TH1F>(TH1F(proto)); for (int b = 1; b <= old_h->GetNbinsX(); ++b) { int new_bin = (bin_mapping.find(b))->second; new_h->SetBinContent( new_bin, new_h->GetBinContent(new_bin) + old_h->GetBinContent(b)); } e->set_shape(std::move(new_h), false); }); cmb_bin.ForEachSyst([&](ch::Systematic *e) { if (e->type() != "shape") return; TH1 const* old_hd = e->shape_d(); TH1 const* old_hu = e->shape_u(); std::unique_ptr<TH1> new_hd = ch::make_unique<TH1F>(TH1F(proto)); std::unique_ptr<TH1> new_hu = ch::make_unique<TH1F>(TH1F(proto)); for (int b = 1; b <= old_hd->GetNbinsX(); ++b) { int new_bin = (bin_mapping.find(b))->second; new_hd->SetBinContent( new_bin, new_hd->GetBinContent(new_bin) + old_hd->GetBinContent(b)); new_hu->SetBinContent( new_bin, new_hu->GetBinContent(new_bin) + old_hu->GetBinContent(b)); } e->set_shapes(std::move(new_hu), std::move(new_hd), nullptr); }); } std::vector<TH1F *> by_chn; auto channels = cmb.channel_set(); THStack stack_bkg; for (auto chn : channels) { by_chn.push_back( new TH1F(cmb.cp().channel({chn}).backgrounds().GetShape())); if (chn == "et") by_chn.back()->SetFillColorAlpha(TColor::GetColor(200, 2, 285),.85); if (chn == "mt") by_chn.back()->SetFillColorAlpha(TColor::GetColor(408, 106, 154),.85); if (chn == "em") by_chn.back()->SetFillColorAlpha(TColor::GetColor(200, 222, 285),.85); if (chn == "tt") by_chn.back()->SetFillColorAlpha(TColor::GetColor(208, 376, 124),.85); if (chn == "ee") by_chn.back()->SetFillColor(TColor::GetColor(247, 186, 254)); if (chn == "mm") by_chn.back()->SetFillColor(TColor::GetColor(112, 142, 122)); if (chn == "vhtt") by_chn.back()->SetFillColor(TColor::GetColor(137, 132, 192)); if (chn == "et") by_chn.back()->SetTitle("e_{}#tau_{h}"); if (chn == "mt") by_chn.back()->SetTitle("#mu_{}#tau_{h}"); if (chn == "em") by_chn.back()->SetTitle("e#mu"); if (chn == "ee") by_chn.back()->SetTitle("ee"); if (chn == "mm") by_chn.back()->SetTitle("#mu#mu"); if (chn == "tt") by_chn.back()->SetTitle("#tau_{h}#tau_{h}"); if (chn == "vhtt") by_chn.back()->SetTitle("VH"); by_chn.back()->SetBinContent(17, 0.); stack_bkg.Add(by_chn.back()); } TH1F sb_sig = cmb.cp().signals().GetShape(); TH1F sb_bkg = cmb.cp().backgrounds().GetShapeWithUncertainty(); TH1F sb_err = sb_bkg; TH1F sb_obs = cmb.cp().GetObservedShape(); sb_sig.SetBinContent(17, 0.); sb_bkg.SetBinContent(17, 0.); sb_obs.SetBinContent(17, 0.); sb_bkg.SetFillColor(18); sb_sig.SetFillColor(kRed); sb_sig.SetFillStyle(3004); sb_sig.SetLineColor(kRed); int new_idx = CreateTransparentColor(12, 0.4); sb_err.SetFillColor(new_idx); sb_err.SetMarkerSize(0); THStack *stack = new THStack("stack", "stack"); stack->Add((TH1F*)sb_bkg.Clone(), "hist"); stack->Add((TH1F*)sb_sig.Clone(), "hist"); TCanvas* canv = new TCanvas(output.c_str(), output.c_str()); canv->cd(); std::vector<TPad*> pads = do_ratio ? TwoPadSplit(0.29, 0.005, 0.005) : OnePad(); pads[0]->SetLogy(do_logy); std::vector<TH1*> h = CreateAxisHists(2, &sb_obs); if (do_ratio) { SetupTwoPadSplitAsRatio(pads, h[0], h[1], "Obs - Bkg", true, -10., 10.); h[1]->GetXaxis()->SetTitle("log(S/S+B)"); h[0]->GetYaxis()->SetTitle("Events"); } else { h[0]->GetXaxis()->SetTitle("log(S/S+B)"); h[0]->GetYaxis()->SetTitle("Events"); } h[0]->Draw(""); if (pads[0]->GetLogy()) h[0]->SetMinimum(0.1); if (blinded){ for (int ibin=0; ibin < sb_obs.GetNbinsX() ; ibin++ ){ if (ibin > 7) sb_obs.SetBinContent(ibin,0); } } stack->Draw("histsame"); stack_bkg.Draw("histsame"); sb_err.Draw("e2same"); sb_obs.Draw("esamex0"); FixTopRange(pads[0], GetPadYMax(pads[0]), 0.15); TLegend *legend = PositionedLegend(0.30, 0.30, 3, 0.03); legend->AddEntry(&sb_obs, "Observed", "pe"); // legend->AddEntry(&sb_bkg, "Background", "f"); for (auto chn: by_chn) { legend->AddEntry(chn, chn->GetTitle(), "f"); } legend->AddEntry(&sb_sig, "Signal", "f"); // legend->AddEntry(&sb_err, "Bkg. Uncertainty", "f"); legend->Draw(); for (auto pad : pads) { pad->cd(); FixOverlay(); } DrawTitle(pads[0], "CMS Preliminary 35.9 fb^{-1} (13 TeV)", 1); // // float lowX=0.65; // float lowY=0.85; // TPaveText * lumi = new TPaveText(lowX, lowY+0.06, lowX+0.30, lowY+0.16, "NDC"); // lumi->SetBorderSize( 0 ); // lumi->SetFillStyle( 0 ); // lumi->SetTextAlign( 12 ); // lumi->SetTextColor( 1 ); // lumi->SetTextSize(0.04); // lumi->SetTextFont ( 42 ); // lumi->AddText("35.9 fb^{-1} (13 TeV)"); // lumi->Draw(); // // lowX=0.15; // lowY=0.75; // TPaveText * lumi1 = new TPaveText(lowX, lowY+0.06, lowX+0.15, lowY+0.16, "NDC"); // lumi1->SetTextFont(61); // lumi1->SetTextSize(0.05); // lumi1->SetBorderSize( 0 ); // lumi1->SetFillStyle( 0 ); // lumi1->SetTextAlign( 12 ); // lumi1->SetTextColor( 1 ); // lumi1->AddText("CMS Preliminary"); // lumi1->Draw(); canv->Print(".pdf"); // TFile outfile((output+".root").c_str(), "RECREATE"); // outfile.cd(); // ch::WriteToTFile(&sb_sig, &outfile, "TotalSig"); // ch::WriteToTFile(&sb_bkg, &outfile, "TotalBkg"); // ch::WriteToTFile(&sb_obs, &outfile, "TotalObs"); // outfile.Close(); return 0; }
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 phi2(double pt1min, double pt2min, double METmin){ TLegend* leg = new TLegend(0.13,0.6,0.87,0.87); leg->SetNColumns(3); leg->SetBorderSize(0); leg->SetFillStyle(0); gStyle->SetPadTickY(1); gStyle->SetPadTickX(1); TFile *data = TFile::Open("./25ns_2246inv_v3/DoubleEG.root","READ"); TFile *sig1 = TFile::Open("./25ns_2246inv_v3/2HDM_mZP600.root","READ"); TFile *sig2 = TFile::Open("./25ns_2246inv_v3/2HDM_mZP800.root","READ"); TFile *sig3 = TFile::Open("./25ns_2246inv_v3/2HDM_mZP1000.root","READ"); TFile *sig4 = TFile::Open("./25ns_2246inv_v3/2HDM_mZP1200.root","READ"); TFile *sig5 = TFile::Open("./25ns_2246inv_v3/2HDM_mZP1400.root","READ"); TFile *sig6 = TFile::Open("./25ns_2246inv_v3/2HDM_mZP1700.root","READ"); TFile *sig7 = TFile::Open("./25ns_2246inv_v3/2HDM_mZP2500.root","READ"); TFile *bkg1 = TFile::Open("./25ns_2246inv_v3/DiPhoton.root","READ"); TFile *bkg2 = TFile::Open("./25ns_2246inv_v3/DYJetsToLL.root","READ"); TFile *bkg3 = TFile::Open("./25ns_2246inv_v3/GJets.root","READ"); TFile *bkg4 = TFile::Open("./25ns_2246inv_v3/GluGluHToGG.root","READ"); TFile *bkg5 = TFile::Open("./25ns_2246inv_v3/QCD.root","READ"); TFile *bkg6 = TFile::Open("./25ns_2246inv_v3/VH.root","READ"); TFile *bkg7 = TFile::Open("./25ns_2246inv_v3/ttHJetToGG.root","READ"); TFile *bkg8 = TFile::Open("./25ns_2246inv_v3/VBFHToGG.root","READ"); TFile *bkg9 = TFile::Open("./25ns_2246inv_v3/TGJets.root","READ"); TFile *bkg10 = TFile::Open("./25ns_2246inv_v3/TTGJets.root","READ"); TFile *bkg11 = TFile::Open("./25ns_2246inv_v3/WGToLNuG.root","READ"); TFile *bkg12 = TFile::Open("./25ns_2246inv_v3/ZGTo2LG.root","READ"); TTree *tree_data = (TTree*) data->Get("DiPhotonTree"); TTree *tree_sig1 = (TTree*) sig1->Get("DiPhotonTree"); TTree *tree_sig2 = (TTree*) sig2->Get("DiPhotonTree"); TTree *tree_sig3 = (TTree*) sig3->Get("DiPhotonTree"); TTree *tree_sig4 = (TTree*) sig4->Get("DiPhotonTree"); TTree *tree_sig5 = (TTree*) sig5->Get("DiPhotonTree"); TTree *tree_sig6 = (TTree*) sig6->Get("DiPhotonTree"); TTree *tree_sig7 = (TTree*) sig7->Get("DiPhotonTree"); TTree *tree_bkg1 = (TTree*) bkg1->Get("DiPhotonTree"); TTree *tree_bkg2 = (TTree*) bkg2->Get("DiPhotonTree"); TTree *tree_bkg3 = (TTree*) bkg3->Get("DiPhotonTree"); TTree *tree_bkg4 = (TTree*) bkg4->Get("DiPhotonTree"); TTree *tree_bkg5 = (TTree*) bkg5->Get("DiPhotonTree"); TTree *tree_bkg6 = (TTree*) bkg6->Get("DiPhotonTree"); TTree *tree_bkg7 = (TTree*) bkg7->Get("DiPhotonTree"); TTree *tree_bkg8 = (TTree*) bkg8->Get("DiPhotonTree"); TTree *tree_bkg9 = (TTree*) bkg9->Get("DiPhotonTree"); TTree *tree_bkg10 = (TTree*) bkg10->Get("DiPhotonTree"); TTree *tree_bkg11 = (TTree*) bkg11->Get("DiPhotonTree"); TTree *tree_bkg12 = (TTree*) bkg12->Get("DiPhotonTree"); TCanvas *c1 = new TCanvas("c1","",500,600); TPad *mainPad = new TPad("mainPad","",0,0.3,1,1); TPad *smallPad = new TPad("smallPad","",0,0.05,1,0.3); mainPad->SetBottomMargin(0.015); smallPad->SetTopMargin(0.05); smallPad->SetBottomMargin(0.25); c1->cd(); mainPad->Draw(); mainPad->cd(); gPad->SetLogy(); TCut mggmax = "mgg<180"; TCut mggmin = "mgg>100"; TCut pt1Cut = Form("pt1/mgg>%lf",pt1min); TCut pt2Cut = Form("pt2/mgg>%lf",pt2min); TCut METCut = Form("t1pfmet>%lf",METmin); TCut eveto1 = "eleveto1 == 1"; TCut eveto2 = "eleveto2 == 1"; TCut eveto = eveto1 && eveto2; TCut genmatch = "((genmatch1==1 && genmatch2==0)||(genmatch1==0 && genmatch2==1)||(genmatch1==0 && genmatch2==0))"; TCut metF = "((metF_GV==1) && (metF_HBHENoise==1) && (metF_HBHENoiseIso==1) && (metF_CSC==1) && (metF_eeBadSC==1))"; tree_data->Draw("(phi2)>>hdata(20,-4,4)",(mggmax && mggmin && metF&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hdata =(TH1F*)gPad->GetPrimitive("hdata"); tree_sig1->Draw("(phi2)>>h1(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *h1 =(TH1F*)gPad->GetPrimitive("h1"); tree_sig2->Draw("(phi2)>>h2(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *h2 =(TH1F*)gPad->GetPrimitive("h2"); tree_sig3->Draw("(phi2)>>h3(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *h3 =(TH1F*)gPad->GetPrimitive("h3"); tree_sig4->Draw("(phi2)>>h4(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *h4 =(TH1F*)gPad->GetPrimitive("h4"); tree_sig5->Draw("(phi2)>>h5(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *h5 =(TH1F*)gPad->GetPrimitive("h5"); tree_sig6->Draw("(phi2)>>h6(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *h6 =(TH1F*)gPad->GetPrimitive("h6"); tree_sig7->Draw("(phi2)>>h7(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *h7 =(TH1F*)gPad->GetPrimitive("h7"); tree_bkg1->Draw("(phi2)>>hbkg1(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hbkg1 =(TH1F*)gPad->GetPrimitive("hbkg1"); tree_bkg2->Draw("(phi2)>>hbkg2(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hbkg2 =(TH1F*)gPad->GetPrimitive("hbkg2"); tree_bkg3->Draw("(phi2)>>hbkg3(20,-4,4)","weight"*(mggmin && mggmax && genmatch&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hbkg3 =(TH1F*)gPad->GetPrimitive("hbkg3"); tree_bkg4->Draw("(phi2)>>hbkg4(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); //weight also on BR = 0.002 if using the 50ns samples TH1F *hbkg4 =(TH1F*)gPad->GetPrimitive("hbkg4"); tree_bkg5->Draw("(phi2)>>hbkg5(20,-4,4)","weight"*(mggmin && mggmax && genmatch&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hbkg5 =(TH1F*)gPad->GetPrimitive("hbkg5"); tree_bkg6->Draw("(phi2)>>hbkg6(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hbkg6 =(TH1F*)gPad->GetPrimitive("hbkg6"); tree_bkg7->Draw("(phi2)>>hbkg7(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hbkg7 =(TH1F*)gPad->GetPrimitive("hbkg7"); tree_bkg8->Draw("(phi2)>>hbkg8(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hbkg8 =(TH1F*)gPad->GetPrimitive("hbkg8"); tree_bkg9->Draw("(phi2)>>hbkg9(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hbkg9 =(TH1F*)gPad->GetPrimitive("hbkg9"); tree_bkg10->Draw("(phi2)>>hbkg10(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hbkg10 =(TH1F*)gPad->GetPrimitive("hbkg10"); tree_bkg11->Draw("(phi2)>>hbkg11(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hbkg11 =(TH1F*)gPad->GetPrimitive("hbkg11"); tree_bkg12->Draw("(phi2)>>hbkg12(20,-4,4)","weight"*(mggmin && mggmax&& METCut &&pt1Cut && pt2Cut&& eveto)); TH1F *hbkg12 =(TH1F*)gPad->GetPrimitive("hbkg12"); hdata->SetMarkerColor(kBlack); hdata->SetMarkerStyle(20); hdata->SetLineColor(kBlack); h1->SetLineColor(kRed+3); h2->SetLineColor(kRed+1); h3->SetLineColor(kRed); h4->SetLineColor(kPink+2); h5->SetLineColor(kPink+4); h6->SetLineColor(kPink+7); h7->SetLineColor(kMagenta+2); h1->SetLineWidth(2); h2->SetLineWidth(2); h3->SetLineWidth(2); h4->SetLineWidth(2); h5->SetLineWidth(2); h6->SetLineWidth(2); h7->SetLineWidth(2); THStack *hs= new THStack("hs",""); hbkg7->SetFillColor(kGreen+2); hbkg6->SetFillColor(kGreen); hbkg8->SetFillColor(kYellow); hbkg4->SetFillColor(kOrange); hbkg9->SetFillColor(kOrange+7); hbkg10->SetFillColor(kOrange+4); hbkg11->SetFillColor(kCyan); hbkg12->SetFillColor(kCyan+1); hbkg5->SetFillColor(kBlue+2); hbkg2->SetFillColor(kBlue); hbkg3->SetFillColor(kMagenta-2); hbkg1->SetFillColor(kViolet); hbkg1->SetLineColor(kBlack); hbkg2->SetLineColor(kBlack); hbkg3->SetLineColor(kBlack); hbkg4->SetLineColor(kBlack); hbkg5->SetLineColor(kBlack); hbkg6->SetLineColor(kBlack); hbkg7->SetLineColor(kBlack); hbkg8->SetLineColor(kBlack); hbkg9->SetLineColor(kBlack); hbkg10->SetLineColor(kBlack); hbkg11->SetLineColor(kBlack); hbkg12->SetLineColor(kBlack); hs->Add(hbkg7); hs->Add(hbkg6); hs->Add(hbkg8); hs->Add(hbkg4); hs->Add(hbkg9); hs->Add(hbkg10); hs->Add(hbkg11); hs->Add(hbkg12); hs->Add(hbkg2); hs->Add(hbkg5); hs->Add(hbkg3); hs->Add(hbkg1); TH1F *hsum = (TH1F*)hbkg1->Clone("hsum"); hsum->Add(hbkg2); hsum->Add(hbkg3); hsum->Add(hbkg4); hsum->Add(hbkg5); hsum->Add(hbkg6); hsum->Add(hbkg7); hsum->Add(hbkg8); hsum->Add(hbkg9); hsum->Add(hbkg10); hsum->Add(hbkg11); hsum->Add(hbkg12); hs->SetMaximum(1000000); hs->SetMinimum(0.1); hs->SetTitle(""); hs->Draw("HIST"); hsum->SetMarkerStyle(1); hsum->SetFillColor(kGray+3); hsum->SetFillStyle(3002); hsum->Draw("same e2"); h2->Draw("same hist"); h3->Draw("same hist"); h4->Draw("same hist"); h1->Draw("same hist"); h5->Draw("same hist"); h6->Draw("same hist"); h7->Draw("same hist"); hdata->Draw("same E1"); hs->GetXaxis()->SetLabelOffset(999); hs->GetYaxis()->SetTitle("Events/0.4"); hs->GetYaxis()->SetTitleOffset(1.2); gPad->Modified(); leg->AddEntry(hdata,"Data","lep"); leg->AddEntry(hbkg1,"#gamma #gamma","f"); leg->AddEntry(h1,"m_{Z'} = 600 GeV","l"); leg->AddEntry(hbkg2,"Drell Yann","f"); leg->AddEntry(hbkg3,"#gamma + Jets","f"); leg->AddEntry(h2,"m_{Z'} = 800 GeV","l"); leg->AddEntry(hbkg5,"QCD","f"); leg->AddEntry(hbkg4,"ggH","f"); leg->AddEntry(h3,"m_{Z'} = 1000 GeV","l"); leg->AddEntry(hbkg6,"VH","f"); leg->AddEntry(hbkg7,"ttH","f"); leg->AddEntry(h4,"m_{Z'} = 1200 GeV","l"); leg->AddEntry(hbkg8,"VBF H","f"); leg->AddEntry(hbkg9,"t + #gamma + Jets","f"); leg->AddEntry(h5,"m_{Z'} = 1400 GeV","l"); leg->AddEntry(hbkg10,"tt + #gamma +Jets","f"); leg->AddEntry(hbkg11,"#gamma+W","f"); leg->AddEntry(h6,"m_{Z'} = 1700 GeV","l"); leg->AddEntry(hbkg12,"#gamma+Z","f"); leg->AddEntry(hsum,"Bkg uncertainty","f"); leg->AddEntry(h7,"m_{Z'} = 2500 GeV","l"); leg->Draw("same"); c1->cd(); smallPad->Draw(); smallPad->cd(); TGraphErrors *gr = new TGraphErrors(0); double integralData=hdata->Integral(); double integralBKG=hsum->Integral(); double error, ratio; for(int w=1; w<20; w++){ if((hdata->GetBinContent(w)!=0) && (hsum->GetBinContent(w)!=0)){ gr->SetPoint(w, hdata->GetBinCenter(w),(hdata->GetBinContent(w))/(hsum->GetBinContent(w))); ratio= (hdata->GetBinContent(w))/(hsum->GetBinContent(w)); error= (hdata->GetBinContent(w)*sqrt(hsum->GetBinContent(w))/(hsum->GetBinContent(w)*hsum->GetBinContent(w)) + sqrt(hdata->GetBinContent(w))/hsum->GetBinContent(w)); std::cout<<"VALUE: "<<ratio<<" ERROR: "<<error<<std::endl; gr->SetPointError(w, hdata->GetBinWidth(w)/2,error); }else{ gr->SetPoint(w, hdata->GetBinCenter(w),10); } } gStyle->SetPadTickY(1); gStyle->SetPadTickX(1); gr->GetHistogram()->SetMaximum(2); gr->GetHistogram()->SetMinimum(0.1); gStyle->SetTextSize(14); gROOT->ForceStyle(); gr->GetXaxis()->SetLabelFont(43); gr->GetXaxis()->SetLabelSize(15); gr->GetYaxis()->SetLabelFont(43); gr->GetYaxis()->SetLabelSize(15); gr->GetXaxis()->SetLimits(-4,4); gPad->SetGrid(); gStyle->SetStripDecimals(kTRUE); gr->SetMarkerStyle(20); gr->SetMarkerSize(0.7); gr->Draw("AZP"); gr->GetXaxis()->SetTitle("#phi_{2}"); gr->GetXaxis()->SetTitleSize(0.1); gr->GetYaxis()->SetTitleSize(0.1); gr->GetYaxis()->SetNdivisions(505); gr->GetXaxis()->SetTitleOffset(1); gr->GetYaxis()->SetTitle("Data/MC"); gr->GetYaxis()->SetTitleOffset(0.4); gr->SetTitle(""); smallPad->Update(); TF1* line = new TF1("line","1",-4,4); line->SetLineColor(kRed); line->SetLineWidth(2); line->Draw("L same"); gr->Draw("ZP SAME"); if(pt1min==0 && pt2min == 0 && METmin == 0){ c1->SaveAs("./25ns_2246inv_v3/plots/kinematics/phi2.png"); c1->SaveAs("./25ns_2246inv_v3/plots/kinematics/phi2.pdf"); } if(pt1min==0.65 && pt2min == 0.25){ c1->SaveAs(Form("./25ns_2246inv_v3/plots/kinematics/phi2_optcuts_MET%.0lf.png",METmin)); c1->SaveAs(Form("./25ns_2246inv_v3/plots/kinematics/phi2_optcuts_MET%.0lf.pdf",METmin)); } }
int main(int argc, char **argv) { TString xvar = "TMath::Power(J_psi_1S_MM/1000,2)"; TString xvarname = "q2"; TString type = "All"; TCut extCut = ""; string drawopt = ""; TString outFileName = ""; bool rel = false, doSys = false, percent = false, jpsi = false, pythia6 = false; int xnbins = 12; double def_xbins[] = {0.1, 2.0, 4.0, 6.0, 8.0, 9.1, 10.1, 11.0, 12.5, 15.0, 16.0, 18.0, 20.0}; //double def_xbins[] = {1.1, 6.0, 15.0, 20.0}; double * xbins = &def_xbins[0]; if(argc > 1) { for(int a = 1; a < argc; a++) { string arg = argv[a]; string str = arg.substr(2,arg.length()-2); if(arg.find("-t") != string::npos) type = (TString)str; if(arg == "-r") rel = true; if(arg.find("-b") != string::npos ) xbins = decodeBinning(str,&xnbins); if(arg.find("-c") != string::npos ) xbins = decodeBinning(str,&xnbins,"custom"); if(arg.find("-C") != string::npos ) extCut = (TCut)((TString)str); if(arg == "-highq2Cut") extCut = (TCut)"( TMath::Power(J_psi_1S_MM/1000,2) > 15. && TMath::Power(J_psi_1S_MM/1000,2) < 20. )"; if(arg == "-Pythia6") pythia6 = true; if(arg.find("-X") != string::npos) { xvar = str; xvarname = xvar; } if(arg.find("-D") != string::npos) drawopt = str; if(arg.find("-sys") != string::npos) doSys = true; if(arg.find("-percent") != string::npos) percent = true; if(arg.find("-o") != string::npos) outFileName = str; if(arg.find("-jpsi") != string::npos) jpsi = true; } } if(jpsi) { if(xvarname=="q2") xbins = decodeBinning("[1,0,25]",&xnbins); rel = false; doSys = false; } // Set trees of cancdidates previously created TString mctype = "MC_Pythia8_NBweighted"; if(pythia6) mctype = "MC_Pythia6_NBweighted"; TString weight = "MCnorm*(lifeTimeW > 0)*(physRate_pol0_noDecay > 0)"; cout << "Using: " << mctype << endl; cout << "Plotting: " << xvar << endl; cout << "Binning: ["; for(int i = 0; i < xnbins; i++) cout << xbins[i] << ","; cout << xbins[xnbins] << "]" << endl; TString namefileMCgeom = "/afs/cern.ch/work/p/pluca/Lmumu/weighted/Lb2Lmumu_geom"+mctype+".root"; TString namefileMC = "/afs/cern.ch/work/p/pluca/Lmumu/weighted/Lb2Lmumu_"+mctype+".root"; TString namefileMCjpsi = "/afs/cern.ch/work/p/pluca/Lmumu/weighted/Lb2JpsiL_"+mctype+".root"; TString namefileMCjpsiGeom = "/afs/cern.ch/work/p/pluca/Lmumu/weighted/Lb2JpsiL_geom"+mctype+".root"; TString namefileDataJpsi = "/afs/cern.ch/work/p/pluca/Lmumu/weighted/Lb2Lmumu_CL_NBweighted.root"; TString nameGeomTree = "MCtree"; if(xvar=="cosThetaB") nameGeomTree = "MCtreeDecay"; TFile * MCfile = TFile::Open(namefileMCgeom); TTree * treeMCgeom = (TTree *)MCfile->Get(nameGeomTree); MCfile = TFile::Open(namefileMC); TTree * treeMC = (TTree *)MCfile->Get("tree"); TTree * treeMCGen = (TTree *)MCfile->Get("MCtreeDecay"); TTree * treeMCAllGen = (TTree *)MCfile->Get("MCtree"); MCfile = TFile::Open("/afs/cern.ch/work/p/pluca/Lmumu/weighted/trainingSamples.root"); TTree * treeMCmva = (TTree *)MCfile->Get("sigTestSample"); TTree * treeMCjpsi = NULL, * treeMCjpsi_Gen = NULL, * treeMCjpsi_AllGen = NULL, * treeMCjpsi_geom = NULL; if(rel || jpsi) { MCfile = TFile::Open(namefileMCjpsi); if(jpsi) { treeMC = (TTree *)MCfile->Get("tree"); treeMCmva = (TTree *)MCfile->Get("tree"); treeMCGen = (TTree *)MCfile->Get("MCtreeDecay"); treeMCAllGen = (TTree *)MCfile->Get("MCtree"); } else { treeMCjpsi = (TTree *)MCfile->Get("tree"); treeMCjpsi_Gen = (TTree *)MCfile->Get("MCtreeDecay"); treeMCjpsi_AllGen = (TTree *)MCfile->Get("MCtree"); } MCfile = TFile::Open(namefileMCjpsiGeom); if(jpsi) treeMCgeom = (TTree *)MCfile->Get(nameGeomTree); else treeMCjpsi_geom = (TTree *)MCfile->Get(nameGeomTree); } TCut geomCut = CutsDef::geomCut; TCut baseCut = extCut + CutsDef::baseCutMuMu; if(jpsi) baseCut = extCut + CutsDef::baseCutJpsi; TCut baseJpsiCut = extCut + CutsDef::baseCutJpsi; TCut binCut = "TMath::Power(J_psi_1S_MM/1000,2) > 9.1 && TMath::Power(J_psi_1S_MM/1000,2) < 10.1"; if(type == "DD") { baseCut += CutsDef::DDcut; baseJpsiCut += CutsDef::DDcut; } else if(type == "LL") { baseCut += CutsDef::LLcut; baseJpsiCut += CutsDef::LLcut; } cout << "Analysisng " << type << " events" << endl; TString myName = "Lbeff"; if(rel) myName = "Lbreleff"; if(doSys) myName += "AndSys"; if(jpsi) myName += "_Jpsi"; myName += ("vs"+xvarname+"_"+type+".root"); if(outFileName!="") myName = outFileName; TFile * histFile = new TFile(myName,"recreate"); /** Calc efficiencies and systematics */ gROOT->ProcessLine(".x ~/work/lhcbStyle.C"); vector <TString> effnames; effnames.push_back("geom"); effnames.push_back("det"); effnames.push_back("reco"); effnames.push_back("mva"); effnames.push_back("trig"); vector <TString> complnames; complnames.push_back("Geometric"); complnames.push_back("Detection"); complnames.push_back("Reconstruction"); complnames.push_back("MVA"); complnames.push_back("Trigger"); vector <TH1F * > hdefault, hsys, hPIDsys; vector <TH1F * > lfsys_plus, lfsys_minus; vector <TH1F * > decaysys, DDsys; vector <TH1F * > polsys_minus, polsys_plus; vector <TH1F * > poljpsi1, poljpsi2, poljpsi3, poljpsi4, poljpsi5, poljpsi6, poljpsi7, poljpsi8; vector <TH1F * > hwilson1, hwilson2, hwilson3; cout << "Analysing GEO sys" << endl; getAllEffSys("GEO", xvar, xnbins, xbins, weight, treeMCgeom, geomCut+extCut, treeMCgeom, extCut, treeMCjpsi_geom, geomCut+extCut+binCut, treeMCjpsi_geom, extCut+binCut, &hdefault, &hsys, NULL, &lfsys_plus, &lfsys_minus, &decaysys, &polsys_minus, &polsys_plus, &poljpsi1, &poljpsi2, &poljpsi3, &poljpsi4, &poljpsi5, &poljpsi6, &poljpsi7, &poljpsi8, &hwilson1, &hwilson2, &hwilson3, &DDsys, doSys, "-f0.5", jpsi); cout << "Analysing DET sys" << endl; if(xvar=="cosThetaB") getAllEffSys("DET", xvar, xnbins, xbins, weight, treeMCGen, extCut, treeMCgeom, geomCut+extCut, treeMCjpsi_Gen, extCut+binCut, treeMCjpsi_AllGen, geomCut+extCut+binCut, &hdefault, &hsys, NULL, &lfsys_plus, &lfsys_minus, &decaysys, &polsys_minus, &polsys_plus, &poljpsi1, &poljpsi2, &poljpsi3, &poljpsi4, &poljpsi5, &poljpsi6, &poljpsi7, &poljpsi8, &hwilson1, &hwilson2, &hwilson3, &DDsys, doSys, "", jpsi ); else getAllEffSys("DET", xvar, xnbins, xbins, weight, treeMCGen, extCut, treeMCAllGen, extCut, treeMCjpsi_Gen, extCut+binCut, treeMCjpsi_AllGen, extCut+binCut, &hdefault, &hsys, NULL, &lfsys_plus, &lfsys_minus, &decaysys, &polsys_minus, &polsys_plus, &poljpsi1, &poljpsi2, &poljpsi3, &poljpsi4, &poljpsi5, &poljpsi6, &poljpsi7, &poljpsi8, &hwilson1, &hwilson2, &hwilson3, &DDsys, doSys, "", jpsi ); cout << "Analysing RECO sys" << endl; getAllEffSys("RECO", xvar, xnbins, xbins, weight, treeMC, baseCut, treeMCGen, extCut, treeMCjpsi, baseJpsiCut+binCut, treeMCjpsi_Gen, extCut+binCut, &hdefault, &hsys, NULL, &lfsys_plus, &lfsys_minus, &decaysys, &polsys_minus, &polsys_plus, &poljpsi1, &poljpsi2, &poljpsi3, &poljpsi4, &poljpsi5, &poljpsi6, &poljpsi7, &poljpsi8, &hwilson1, &hwilson2, &hwilson3, &DDsys, doSys, "", jpsi ); cout << "Analysing MVA sys" << endl; getAllEffSys("MVA", xvar, xnbins, xbins, weight, treeMCmva, baseCut+CutsDef::MVAcut, treeMCmva, baseCut, treeMCjpsi, baseJpsiCut+CutsDef::MVAcut+binCut, treeMCjpsi, baseJpsiCut+binCut, &hdefault, &hsys, &hPIDsys, &lfsys_plus, &lfsys_minus, &decaysys, &polsys_minus, &polsys_plus, &poljpsi1, &poljpsi2, &poljpsi3, &poljpsi4, &poljpsi5, &poljpsi6, &poljpsi7, &poljpsi8, &hwilson1, &hwilson2, &hwilson3, &DDsys, doSys, "", jpsi ); cout << "Analysing TRIG sys" << endl; getAllEffSys("TRIG", xvar, xnbins, xbins, weight, treeMC, baseCut+CutsDef::MVAcut+CutsDef::TrigPassed, treeMC, baseCut+CutsDef::MVAcut, treeMCjpsi, baseJpsiCut+CutsDef::MVAcut+CutsDef::TrigPassed+binCut, treeMCjpsi, baseJpsiCut+CutsDef::MVAcut+binCut, &hdefault, &hsys, &hPIDsys, &lfsys_plus, &lfsys_minus, &decaysys, &polsys_minus, &polsys_plus, &poljpsi1, &poljpsi2, &poljpsi3, &poljpsi4, &poljpsi5, &poljpsi6, &poljpsi7, &poljpsi8, &hwilson1, &hwilson2, &hwilson3, &DDsys, doSys, "", jpsi ); TH1F * toteff_lowSel = NULL; if(rel || jpsi) { TString polweight = "physRate_polp006"; if(jpsi) polweight = "physRate_pol0"; TH1F * mva_lowSel = getEff("UPPER", xvar, xnbins, xbins, treeMCmva, baseCut+CutsDef::MVAcut, treeMCmva, baseCut, weight+"*lifeTimeW*Lb_weight*"+polweight, treeMCjpsi, baseJpsiCut+CutsDef::MVAcut_lowSel+binCut, treeMCjpsi, baseJpsiCut+binCut, weight+"*lifeTimeW*physRate_pol0*pt_weight" ); mva_lowSel->Write("hmvaeff_lowSel"); TH1F * uppereff_lowSel = (TH1F *)hdefault[2]->Clone("huppereff_lowSel"); uppereff_lowSel->Multiply(hdefault[3]); uppereff_lowSel->Multiply(mva_lowSel); toteff_lowSel = (TH1F *)hdefault[0]->Clone("htoteff_lowSel"); toteff_lowSel->Multiply(hdefault[1]); toteff_lowSel->Multiply(uppereff_lowSel); uppereff_lowSel->Write("huppereff_lowSel"); toteff_lowSel->Write("htoteff_lowSel"); if(jpsi) { TH1F * pid = getEff("MCPID", xvar, xnbins, xbins, treeMC, baseCut+"pplus_PIDp > -5", treeMC, baseCut, weight+"*lifeTimeW*Lb_weight*"+polweight); cout << pid->GetBinCenter(1) << " " << pid->GetBinContent(1) << " +/- " << pid->GetBinError(1) << endl; } } TCanvas * c = new TCanvas(); gStyle->SetOptStat(0); gStyle->SetOptFit(); TH1F * uppereff = (TH1F *)hdefault[2]->Clone("huppereff"); uppereff->Multiply(hdefault[3]); uppereff->Multiply(hdefault[4]); TH1F * toteff = (TH1F *)hdefault[0]->Clone("htoteff"); if(xvar=="cosThetaB") hdefault[1]->Scale(1./hdefault[1]->Integral()); toteff->Multiply(hdefault[1]); toteff->Multiply(uppereff); toteff->SetTitle("Total eff"); toteff->Draw(); //toteff->Fit("pol2"); c->Print("effvs"+xvarname+"_"+type+"_tot.pdf"); toteff->Write("htoteff"); //uppereff->Fit("pol2"); uppereff->Draw(); c->Print("effvs"+xvarname+"_"+type+"_upper.pdf"); uppereff->Write("huppereff"); TH1F * tot_nodet_eff = (TH1F *)hdefault[0]->Clone("htot_nodet_eff"); tot_nodet_eff->Multiply(uppereff); tot_nodet_eff->Write("htot_nodet_eff"); TH1F * syseff = (TH1F *)hsys[0]->Clone("hsyseff"); syseff->Multiply(hsys[1]); syseff->Multiply(hsys[2]); syseff->Multiply(hsys[3]); syseff->Multiply(hsys[4]); syseff->Write("sys_eff"); /* TH1F * Kinsys = (TH1F *)syseff->Clone("Kinsys"); Kinsys->Add(toteff,-1); Kinsys->GetXaxis()->SetTitle("q^{2} (GeV^{2})"); Kinsys->GetYaxis()->SetTitle("(eff^{now} - eff^{w})");// / eff^{w}"); Kinsys->Draw(); c->Print("Kin_sys.pdf"); TH1F * PIDsyseff = (TH1F *)hPIDsys[0]->Clone("hPIDsyseff"); PIDsyseff->Multiply(hPIDsys[1]); TH1F * PIDdefeff = (TH1F *)hdefault[3]->Clone("hdefPID"); PIDdefeff->Multiply(hdefault[4]); TH1F * PIDsys = (TH1F *)PIDsyseff->Clone("PIDsys"); PIDsys->Add(PIDdefeff,-1); //PIDsys->Divide(toteff,1,"B"); PIDsys->Write("PIDmuSys"); PIDsys->GetXaxis()->SetTitle("q^{2} (GeV^{2})"); PIDsys->GetYaxis()->SetTitle("(eff^{now} - eff^{w})");// / eff^{w}"); PIDsys->Draw(); c->Print("PIDmu_sys.pdf"); */ for(unsigned i = 0; i < effnames.size(); i++) { //hdefault[i]->Fit("pol2"); if(!jpsi) for(int b = 0; b < hdefault[i]->GetNbinsX(); b++) { hdefault[i]->SetBinContent(hdefault[i]->GetXaxis()->FindBin(8.5),0); hdefault[i]->SetBinError(hdefault[i]->GetXaxis()->FindBin(8.5),0); hdefault[i]->SetBinContent(hdefault[i]->GetXaxis()->FindBin(10.5),0); hdefault[i]->SetBinError(hdefault[i]->GetXaxis()->FindBin(10.5),0); } if(rel) hdefault[i]->SetMinimum(0.5); if(rel) hdefault[i]->SetMaximum(1.5); hdefault[i]->GetXaxis()->SetTitle("q^{2} [GeV^{2}/#it{c}^{4}]"); hdefault[i]->GetYaxis()->SetTitle("Efficiency"); hdefault[i]->SetTitle(complnames[i]); hdefault[i]->Draw(); c->Print("effvs"+xvarname+"_"+type+"_"+effnames[i]+".pdf"); hdefault[i]->Write("h"+effnames[i]+"eff"); } gStyle->SetOptFit(0); /** Printing out efficiencies and systematics **/ vector <TString> sysnames; sysnames.push_back("Lifetime"); sysnames.push_back("Decay Model"); sysnames.push_back("Polarization"); if(type=="DD") sysnames.push_back("DD vtx"); /** Print efficiencies */ cout << "\n\n" << xvarname << " bin " << " \t\t\t& "; for(unsigned s = 0; s < effnames.size(); s++) cout << effnames[s] << " \t\t\t\t& "; cout << "Upper \t\t\t\t& Total \\\\" << endl; TGraphErrors * grtoteff = new TGraphErrors(); TGraphErrors * grtoteff_lowSel = new TGraphErrors(); for(int j = 1; j <= toteff->GetNbinsX(); j++) { if((xbins[j]==11 && !rel) || xbins[j]==15) continue; if(xbins[j]==9.1 || xbins[j-1]==10.1) continue; cout << fixed << setprecision(1) << "eff " << xbins[j-1] << "-" << xbins[j] << fixed << setprecision(5) << " \t & "; for(unsigned i = 0; i < hdefault.size(); i++) cout << "$" << hdefault[i]->GetBinContent(j) << " \\pm " << hdefault[i]->GetBinError(j) << "$ \t & "; cout << "$" << uppereff->GetBinContent(j) << " \\pm " << uppereff->GetBinError(j) << "$ \t & "; cout << "$" << toteff->GetBinContent(j) << " \\pm " << toteff->GetBinError(j) << "$ \\\\ " << endl; grtoteff->SetPoint(j,toteff->GetBinCenter(j),toteff->GetBinContent(j)); grtoteff->SetPointError(j,toteff->GetBinWidth(j)/2.,toteff->GetBinError(j)); if(toteff_lowSel) grtoteff_lowSel->SetPoint(j,toteff_lowSel->GetBinCenter(j),toteff_lowSel->GetBinContent(j)); if(toteff_lowSel) grtoteff_lowSel->SetPointError(j,toteff_lowSel->GetBinWidth(j)/2.,toteff_lowSel->GetBinError(j)); } grtoteff->Write("toteff"); if(toteff_lowSel) grtoteff_lowSel->Write("toteff_lowSel"); if(!doSys) { delete MCfile; delete histFile; return 0; } /** Print sys separate in efficiency */ vector < TH1F * > tmp; vector < vector < TH1F * > > sys_eff(4,tmp); vector < TH1F * > tot_sys_eff; vector < TH1F * > wilson1_sys_eff, wilson2_sys_eff, wilson3_sys_eff; cout << endl << endl << endl; if(!percent) cout << "\n\n" << xvarname << " bin\t\t& Value \t & Stats"; else cout << "\n\n" << xvarname << " bin "; for(unsigned s = 0; s < sysnames.size(); s++) cout << "\t& " << sysnames[s]; cout << " \\\\" << endl; for(int j = 1; j <= toteff->GetNbinsX(); j++) { if((xbins[j]==10.1 && !rel) || xbins[j]==15 || xbins[j]==9.1 || xbins[j]==11) continue; cout << "-----------------------------------------------------------------------------------------" << endl; cout << fixed << setprecision(1) << xbins[j-1] << "-" << xbins[j] << fixed << setprecision(3) << endl; cout << "-----------------------------------------------------------------------------------------" << endl; if(!percent) cout << fixed << setprecision(5); for(unsigned i = 0; i < effnames.size(); i++) { if(j==1) { sys_eff[0].push_back((TH1F*)toteff->Clone("sys_lf_"+effnames[i])); sys_eff[1].push_back((TH1F*)toteff->Clone("sys_decay_"+effnames[i])); sys_eff[2].push_back((TH1F*)toteff->Clone("sys_pol_"+effnames[i])); sys_eff[3].push_back((TH1F*)toteff->Clone("sys_DD_"+effnames[i])); tot_sys_eff.push_back((TH1F*)toteff->Clone("tot_sys_eff")); wilson1_sys_eff.push_back((TH1F*)toteff->Clone("wilson1_sys")); wilson2_sys_eff.push_back((TH1F*)toteff->Clone("wilson2_sys")); wilson3_sys_eff.push_back((TH1F*)toteff->Clone("wilson3_sys")); sys_eff[0][i]->Reset(); sys_eff[1][i]->Reset(); sys_eff[2][i]->Reset(); sys_eff[3][i]->Reset(); tot_sys_eff[i]->Reset(); wilson1_sys_eff[i]->Reset(); wilson2_sys_eff[i]->Reset(); wilson3_sys_eff[i]->Reset(); } double lf_sys = createSys(j,hdefault[i], lfsys_minus[i], lfsys_plus[i]); double decay_sys = createSys(j,hdefault[i], decaysys[i], decaysys[i]); double DD_sys = 0; double pol_sys = createSys(j, hdefault[i], polsys_minus[i], polsys_plus[i]); pol_sys = createSys(j, hdefault[i], poljpsi1[i], poljpsi2[i], pol_sys); pol_sys = createSys(j, hdefault[i], poljpsi3[i], poljpsi4[i], pol_sys); pol_sys = createSys(j, hdefault[i], poljpsi5[i], poljpsi6[i], pol_sys); pol_sys = createSys(j, hdefault[i], poljpsi7[i], poljpsi8[i], pol_sys); double cureff = hdefault[i]->GetBinContent(j); double curerr = hdefault[i]->GetBinError(j); double tot_eff_sys = TMath::Sqrt( TMath::Power(lf_sys,2) + TMath::Power(pol_sys,2) + TMath::Power(decay_sys,2) ); double wilson_sys1 = createSys(j, hdefault[i], hwilson1[i], hwilson1[i]); double wilson_sys2 = createSys(j, hdefault[i], hwilson2[i], hwilson2[i]); double wilson_sys3 = createSys(j, hdefault[i], hwilson3[i], hwilson3[i]); if(type=="DD") { DD_sys = createSys(j, hdefault[i], DDsys[i], DDsys[i]); tot_eff_sys = TMath::Sqrt( TMath::Power(tot_eff_sys,2) + TMath::Power(DD_sys,2) ); sys_eff[3][i]->SetBinContent(j,DD_sys); } cout << effnames[i] << " \t & "; if(percent) { cout << lf_sys*100 << "\\% \t & " << decay_sys*100 << "\\% \t & " << pol_sys*100 << "\\% \t"; if(type=="DD") cout << " & " << DD_sys*100 << " \t "; } else { cout << cureff << " \t & " << curerr << " \t & "; cout << lf_sys*cureff << " \t & " << decay_sys*cureff << " \t & " << pol_sys*cureff << " \t"; if(type=="DD") cout << " & " << DD_sys*cureff << " \t"; } cout << " \\\\ " << endl; sys_eff[0][i]->SetBinContent(j,lf_sys); sys_eff[1][i]->SetBinContent(j,decay_sys); sys_eff[2][i]->SetBinContent(j,pol_sys); tot_sys_eff[i]->SetBinContent(j,tot_eff_sys); wilson1_sys_eff[i]->SetBinContent(j,wilson_sys1); wilson2_sys_eff[i]->SetBinContent(j,wilson_sys2); wilson3_sys_eff[i]->SetBinContent(j,wilson_sys3); } } /** Print total sys */ vector< TH1F * > sys; TH1F * tot_sys = getErrHist(toteff); for(unsigned s = 0; s < sysnames.size(); s++) { TH1F * tmp_sys = NULL; for(unsigned i = 0; i < effnames.size(); i++) tmp_sys = sqSum(tmp_sys,sys_eff[s][i]); sys.push_back( tmp_sys ); tmp_sys->Write("sys_"+sysnames[s]); tot_sys = sqSum(tot_sys,tmp_sys); } tot_sys->Write("sys_tot"); TH1F * wilson_sys1 = NULL, * wilson_sys2 = NULL, * wilson_sys3 = NULL; for(unsigned i = 0; i < effnames.size(); i++) { wilson_sys1 = sqSum(wilson_sys1,wilson1_sys_eff[i]); wilson_sys2 = sqSum(wilson_sys2,wilson2_sys_eff[i]); wilson_sys3 = sqSum(wilson_sys3,wilson3_sys_eff[i]); } wilson_sys1->SetBinContent(wilson_sys1->GetXaxis()->FindBin(8.5),0); wilson_sys1->SetBinError(wilson_sys1->GetXaxis()->FindBin(8.5),0); wilson_sys1->SetBinContent(wilson_sys1->GetXaxis()->FindBin(10.5),0); wilson_sys1->SetBinError(wilson_sys1->GetXaxis()->FindBin(10.5),0); wilson_sys1->SetBinContent(wilson_sys1->GetXaxis()->FindBin(13.),0); wilson_sys1->SetBinError(wilson_sys1->GetXaxis()->FindBin(13.),0); wilson_sys1->Write("rel_wilson_sys1"); wilson_sys1->SetTitle("Relative Wilson Coeff variation sys (CNP[7]=-0.05, CNP[9]=-1.3)"); wilson_sys1->Draw(); c->Print("rel_wilson1_sys"+type+".pdf"); wilson_sys2->SetBinContent(wilson_sys2->GetXaxis()->FindBin(8.5),0); wilson_sys2->SetBinError(wilson_sys2->GetXaxis()->FindBin(8.5),0); wilson_sys2->SetBinContent(wilson_sys2->GetXaxis()->FindBin(10.5),0); wilson_sys2->SetBinError(wilson_sys2->GetXaxis()->FindBin(10.5),0); wilson_sys2->SetBinContent(wilson_sys2->GetXaxis()->FindBin(13.),0); wilson_sys2->SetBinError(wilson_sys2->GetXaxis()->FindBin(13.),0); wilson_sys2->Write("rel_wilson_sys2"); wilson_sys2->SetTitle("Relative Wilson Coeff variation sys (CNP[7]=-0.03, CNP[9]=-1.7)"); wilson_sys2->Draw(); c->Print("rel_wilson2_sys"+type+".pdf"); wilson_sys3->SetBinContent(wilson_sys3->GetXaxis()->FindBin(8.5),0); wilson_sys3->SetBinError(wilson_sys3->GetXaxis()->FindBin(8.5),0); wilson_sys3->SetBinContent(wilson_sys3->GetXaxis()->FindBin(10.5),0); wilson_sys3->SetBinError(wilson_sys3->GetXaxis()->FindBin(10.5),0); wilson_sys3->SetBinContent(wilson_sys3->GetXaxis()->FindBin(13.),0); wilson_sys3->SetBinError(wilson_sys3->GetXaxis()->FindBin(13.),0); wilson_sys3->Write("rel_wilson_sys3"); wilson_sys3->SetTitle("Relative Wilson Coeff variation sys (CNP[7]= 0.01, CNP[9]=-2.1)"); wilson_sys3->Draw(); c->Print("rel_wilson3_sys"+type+".pdf"); cout << endl << endl << endl; if(!percent) cout << "\n\n" << xvarname << " bin\t\t& Value \t & Stats"; else cout << "\n\n" << xvarname << " bin "; for(unsigned s = 0; s < sysnames.size(); s++) cout << " \t & " << sysnames[s]; cout << " \t & Total \\\\" << endl; for(unsigned i = 0; i < effnames.size(); i++) { TGraphErrors * grtot_eff = new TGraphErrors(); cout << endl << effnames[i] << endl; for(int j = 1; j <= toteff->GetNbinsX(); j++) { if((xbins[j]==10.1 && !rel) || xbins[j]==15 || xbins[j] == 9.1 || xbins[j]==11) continue; cout << fixed << setprecision(1) << xbins[j-1] << "-" << xbins[j] << fixed << setprecision(3) << " \t & "; double cureff = hdefault[i]->GetBinContent(j); if(!percent) cout << fixed << setprecision(5) << cureff << " \t & " << hdefault[i]->GetBinError(j) << " \t & "; for(unsigned s = 0; s < sysnames.size(); s++) if(percent) cout << sys_eff[s][i]->GetBinContent(j)*100 << "\\% \t & "; else cout << sys_eff[s][i]->GetBinContent(j)*cureff << " \t & "; if(percent) cout << tot_sys_eff[i]->GetBinContent(j)*100 << "\\% "; else cout << tot_sys_eff[i]->GetBinContent(j)*cureff; //if(percent) cout << wilson_sys_eff[i]->GetBinContent(j)*100 << "\\%"; //else cout << wilson_sys_eff[i]->GetBinContent(j)*cureff; cout << " \\\\ " << endl; grtot_eff->SetPoint(j,tot_sys_eff[i]->GetBinCenter(j),tot_sys_eff[i]->GetBinContent(j)); grtot_eff->SetPointError(j,tot_sys_eff[i]->GetBinWidth(j)/2.,0.); } grtot_eff->Write(effnames[i]+"sys"); } cout << endl << endl; if(!percent) cout << "\n\n" << xvarname << " bin\t\t& Value \t\t & Stats"; else cout << "\n\n" << xvarname << " bin "; for(unsigned s = 0; s < sysnames.size(); s++) cout << " \t\t & " << sysnames[s]; cout << " \t\t & Wilson Coeff sys"; cout << " \\\\" << endl; TGraphErrors * grtot = new TGraphErrors(); for(int j = 1; j <= toteff->GetNbinsX(); j++) { if((xbins[j]==11 && !rel) || xbins[j]==15) continue; cout << fixed << setprecision(1) << xbins[j-1] << "-" << xbins[j] << fixed << setprecision(3); double cureff = toteff->GetBinContent(j); if(!percent) cout << fixed << setprecision(5) << cureff << " \t\t & " << toteff->GetBinError(j); for(unsigned s = 0; s < sysnames.size(); s++) if(percent) cout << " \t\t & " << sys[s]->GetBinContent(j)*100 << "\\% "; else cout << " \t\t & " << sys[s]->GetBinContent(j)*cureff; //if(percent) cout << " \t\t & " << wilson_sys->GetBinContent(j)*100 << "\\% "; //else cout << " \t\t & " << wilson_sys->GetBinContent(j)*cureff; cout << " \\\\ " << endl; grtot->SetPoint(j,tot_sys->GetBinCenter(j),tot_sys->GetBinContent(j)); grtot->SetPointError(j,tot_sys->GetBinWidth(j)/2.,0.); } grtot->Write("totsys"); /* cout << "\n\n" << xvarname << " bin\t\t& Value \\\\" << endl; for(int j = 1; j <= toteff->GetNbinsX(); j++) { if((xbins[j]==11 && !rel) || xbins[j]==15) continue; cout << fixed << setprecision(1) << xbins[j-1] << "-" << xbins[j] << fixed << setprecision(5) << " \t & "; cout << "$" << toteff->GetBinContent(j) << " \\pm " << tot_sys->GetBinContent(j)*toteff->GetBinContent(j) << "$ \\\\ " << endl; } */ delete MCfile; delete histFile; return 0; }
void PlotPubHisto(TObjArray histograms,TEnv *params){ // This is a modification of the AddHistos macro // Number of histos to plot: Int_t ntot = histograms.GetEntries(); // Check we have what we expect (the order should be: data, qcd, wjets, etc...) for(Int_t i = 0; i<ntot; i++){ if(histograms[i]==0) { cout<<"Error in AddHistos: histogram "<<i<<" is a NULL pointer!"<<endl; return; } TH1F * hthis = (TH1F*) histograms[i]; // include the overflow/underflow bins: int numbins = hthis->GetNbinsX(); //this is the last bin plotted double hicontent = hthis->GetBinContent(numbins); double overflow = hthis->GetBinContent(numbins+1);// this bin contains the overflow double locontent = hthis->GetBinContent(1);// this is the first bin plotted double underflow = hthis->GetBinContent(0);// this bin contains the underflow if (underflow>0 || overflow>0){ //printf("%-20s numbins=%4i hicontent=%4.2f over=%4.2f locontent=%4.2f underflow=%4.2f \n", // title.Data(),numbins,hicontent,overflow,locontent,underflow); } hthis->SetBinContent(numbins,hicontent+overflow); hthis->SetBinContent(1,locontent+underflow); } // define a few additional line styles: gStyle->SetLineStyleString(5,"20 12 4 12"); gStyle->SetLineStyleString(6,"20 12 4 12 4 12 4 12"); gStyle->SetLineStyleString(7,"20 20"); gStyle->SetLineStyleString(8,"20 12 4 12 4 12"); gStyle->SetLineStyleString(9,"80 25"); gStyle->SetLineStyleString(10,"50 10 10 10"); gStyle->SetLineStyleString(17,"30 25"); gStyle->SetLineStyleString(20,"60 20"); gStyle->SetLineStyleString(21,"60 20 20 20"); int lineStyle[20]; for(int i=0;i<20;i++) { lineStyle[i]=i; } // the first histogram in the list: TH1F *h0=((TH1F*) histograms[0])->Clone(); // histogram output filename TString oFileName=params->GetValue("Histo.Output.Filename","bogus.eps"); // figure out the number of signals Int_t nsig=1; if(params->Defined("Histo.Signal.Title.1")) nsig=1; if(params->Defined("Histo.Signal.Title.2")) nsig=2; if(params->Defined("Histo.Signal.Title.3")) nsig=3; cout << " I will use nsig = " << nsig << " signal sources" << endl; // Do the cumulative summing, except for the data TObjArray addedhistos; addedhistos.Clear(); TObjArray signalhistos; signalhistos.Clear(); TString sampletitles[20]; Int_t nbkg=0; for(Int_t i = 1; i<ntot; i++){// i runs over histograms[i], so data is for i=0 ostringstream baseSrcName; baseSrcName << "Files." << i+1 << ".";// Counting starts at 1: Files.1.Name: Data TString bSrcName(baseSrcName.str().c_str()); // skip some if we want to show them as lines TString htitle=params->GetValue(bSrcName+"Title",""); sampletitles[i-1]=htitle; if(params->GetValue("Histo.ShowSignalSeparately",0)==1 && // skip the last two if the signal title is not defined: ( ( !(params->Defined("Histo.Signal.Title")||params->Defined("Histo.Signal.Title.1")) && i>=ntot-nsig) // skip the signal if the signal title is defined || params->GetValue("Histo.Signal.Title",".")==htitle || params->GetValue("Histo.Signal.Title.1",".")==htitle || params->GetValue("Histo.Signal.Title.2",".")==htitle || params->GetValue("Histo.Signal.Title.3",".")==htitle ) ) { TH1F * hthis = (TH1F*) histograms[i]->Clone(); cout<<" Found signal in location "<<i+1<<" with name "<<htitle.Data()<<endl; signalhistos.Add(hthis); } else { TH1F * hthis = (TH1F*) histograms[i]->Clone(); addedhistos.Add(hthis); // Fill in the new TObjArray with a copy //cout << " Adding bkg " << i << " " << htitle.Data() << " " << hthis->Integral() << endl; // add all of the backgrounds if (i>1) {// i=0 is the data, and we must start with the second // background to add the previous TH1F * hprevious = (TH1F*) addedhistos[i-2]; if ( hthis->GetXaxis()->GetNbins() != hprevious->GetXaxis()->GetNbins() ) { // Protection against _whoran histogram. // We cannot add two histograms with different numbers of bins! cout<<"Error in AddHistos: incompatible number of bins!"<<endl; return; } hthis->Add(hprevious); // Do the addition addedhistos.RemoveAt(i-1); // And substitute whatever we had addedhistos.AddAt(hthis,i-1); nbkg++; //cout << "Substituing bkg " << i << " + " << i-1 << " in addedhistos["<< i-1 <<"]" << endl; } } // end of: if adding histograms } cout << " nbkg = " << nbkg << endl; // Rebin histos if necessary, but first calculate KS: TH1F *hbkg = (TH1F*) addedhistos[nbkg]; double KS = h0->KolmogorovTest(hbkg); double chi2ndf = h0->Chi2Test(hbkg, "UWUFOFCHI2/NDF"); //cout << title.Data() << " KS = " << KS << " chi2/NDF = " << chi2ndf << endl; // Rebin? Set nrebin = 0 to NOT do rebinning. // Will rebin only histos whose maximum x axis value exceeds 20. // Anything with less will most probably be already made of integers, so no // need to rebin that! Int_t nbinsx = h0->GetXaxis()->GetNbins(); Int_t nbinsy = 100; Int_t nrebin = 5; if ( nbinsx > 750 && nbinsx <= 1000) nrebin = 30; if ( nbinsx > 400 && nbinsx <= 750 ) nrebin = 25;//20 if ( nbinsx > 300 && nbinsx <= 400 ) nrebin = 25;//15 if ( nbinsx > 200 && nbinsx <= 300 ) nrebin = 25;//15 if ( nbinsx > 150 && nbinsx <= 200 ) nrebin = 10;//10 if ( nbinsx > 100 && nbinsx <= 150 ) nrebin = 10;//10 if ( nbinsx > 50 && nbinsx <= 100 ) nrebin = 10;//10 if ( nbinsx > 20 && nbinsx <= 50 ) nrebin = 2; if ( nbinsx <= 20 ) nrebin = 1; printf(" Saw nbins =%4i, rebinning by nrebin =%2i to final %3i bins \n",nbinsx,nrebin,int(nbinsx/nrebin)); if ( nrebin != 0 ) { h0->Rebin(nrebin); // data for (Int_t i = 0; i<=nbkg; i++){ TH1F * h = (TH1F*) addedhistos[i]; h->Rebin(nrebin); } for (Int_t i = 0; i<nsig; i++){ TH1F * h = (TH1F*) signalhistos[i]; h->Rebin(nrebin); } } // default text size: 0.045 // make it bigger for the paper float textSize = 0.045; if(params->GetValue("Histo.Preliminary","yes")==TString("paper")) textSize=0.07; if(params->Defined("Histo.TextSize")) textSize=params->GetValue("Histo.TextSize",0.07); // Now, check largest dimensions so that we can plot all histograms at once. Float_t xmin=9999., xmax=-9999., ymin=9999., ymax=-9999.; for(Int_t i = 0; i<=nbkg; i++){ TH1F * h = (TH1F*) addedhistos[i]; ostringstream baseSrcName; baseSrcName << "Files." << i+1 << "."; TString bSrcName(baseSrcName.str().c_str()); TAxis *axis = h->GetXaxis(); if( axis->GetXmin() < xmin ) xmin = axis->GetXmin(); if( axis->GetXmax() > xmax ) xmax = axis->GetXmax(); if( h->GetMinimum() < ymin ) ymin = h->GetMinimum(); if( h->GetMaximum() > ymax ) ymax = h->GetMaximum(); } ymax = TMath::Nint(ymax*1.25+1); // Make enough room for the big legend TString title = h0->GetTitle(); // // now check if we should simply use the ranges that was passed to us. if(params->Defined("Histo.Xmin")) xmin = params->GetValue("Histo.Xmin",0.); if(params->Defined("Histo.Xmax")) xmax = params->GetValue("Histo.Xmax",0.); if(params->Defined("Histo.Ymin")) ymin = params->GetValue("Histo.Ymin",0.); if(params->Defined("Histo.Ymax")) ymax = params->GetValue("Histo.Ymax",0.); // Now make the frame: TH2F * frame = new TH2F("frame","",nbinsx,xmin,xmax,nbinsy,ymin,ymax); cout<<" frame has xmin "<<xmin<<", xmax "<<xmax<<", ymax "<<ymax<<endl; // get the x- and y-axis titles TString ytitle=params->GetValue("Histo.YTitle",""); if ( params->Defined("Histo.XTitle")) { frame->SetXTitle(params->GetValue("Histo.XTitle","")); } else { frame->SetXTitle(h0->GetTitle()); } frame->SetYTitle(ytitle.Data()); // also set the text size for the X and Y axis titles and numbers // do this globally for the style we are using float axisLabelSize=textSize; frame->GetXaxis()->SetLabelSize(axisLabelSize); frame->GetYaxis()->SetLabelSize(axisLabelSize); frame->GetXaxis()->SetTitleSize(axisLabelSize); frame->GetYaxis()->SetTitleSize(axisLabelSize); frame->SetStats(false); // reduce the axis title offset if the fonts are very large if(textSize>0.055) frame->GetXaxis()->SetTitleOffset(1.0); // also change the X axis title offset to move it farther away from the numbers if(params->Defined("Histo.XTitle.Offset")) { float xtitoffset=params->GetValue("Histo.XTitle.Offset",1.0); frame->GetXaxis()->SetTitleOffset(xtitoffset); } // also change the y axis title offset to move it farther away from the numbers frame->GetYaxis()->SetTitleOffset(1.0); // reduce the axis title offset if the fonts are very large if(textSize>0.055) frame->GetYaxis()->SetTitleOffset(1.0); // set the axes divisions frame->GetXaxis()->SetNdivisions(505,true); if(params->Defined("Histo.XNdivisions")) frame->GetXaxis()->SetNdivisions(params->GetValue("Histo.XNdivisions",505),kTRUE); if(params->Defined("Histo.YNdivisions")) frame->GetYaxis()->SetNdivisions(params->GetValue("Histo.YNdivisions",505),kTRUE); // make sure the X axis title and Y axis title are in black! frame->GetXaxis()->SetTitleColor(1); frame->GetYaxis()->SetTitleColor(1); // Could plot in log scale... //gPad->SetLogy(); // finally: Draw frame->Draw(); // Draw the background ones: for(Int_t i=nbkg; i>=0; i--){ TH1F * h = (TH1F*) addedhistos[i]; h->SetStats(kFALSE); ostringstream baseSrcName; baseSrcName << "Files." << i+2 << ".";// to account for the data which is Files.1 TString bSrcName(baseSrcName.str().c_str()); Int_t hcolor=params->GetValue(bSrcName+"Color",1); h->SetLineColor(1); h->SetFillColor(hcolor); if (i==nbkg) printf(" Data Yield = %5.2f ; SumBkg = %5.2f ; Data-SumBkg diff = %5.2f%% \n", h0->Integral(),h->Integral(),(h0->Integral()-h->Integral())*100./h0->Integral()); printf(" plotting bkg i=%2i name=%20.20s file=%2i integral=%5.1f color=%2i\n", i,sampletitles[i].Data(),i+2,h->Integral(),hcolor); int fillStyle=params->GetValue(bSrcName+"FillStyle",1001); h->SetFillStyle(fillStyle); h->DrawCopy("Hist,Same"); } // // and draw the signal ones // draw them in reverse order so that the last one will be on top. //for(Int_t i=ntot-3; i<ntot; i++){ for(Int_t i=nsig-1; i>=0; i--){ ostringstream baseSrcName; baseSrcName << "Files." << ntot+1-nsig+i << "."; TString bSrcName(baseSrcName.str().c_str()); Int_t hcolor=params->GetValue(bSrcName+"Color",1); TH1F * h = (TH1F*) signalhistos[i]; if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=90")) h->Add (h, 1.07874865 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=100")) h->Add (h, 1.62317373 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=110")) h->Add (h, 2.31347600 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=120")) h->Add (h, 3.25275183 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=130")) h->Add (h, 4.54142919 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=140")) h->Add (h, 6.19195046 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=150")) h->Add (h, 8.38307290 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=160")) h->Add (h, 11.31721008 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=170")) h->Add (h, 14.85376469 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=180")) h->Add (h, 19.54537459 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=190")) h->Add (h, 25.44594010 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=200")) h->Add (h, 32.94784356 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=220")) h->Add (h, 54.09499080 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=240")) h->Add (h, 86.85079034 -1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=260")) h->Add (h, 136.31406761-1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=280")) h->Add (h, 210.70375053-1.000); else if (sampletitles[ntot-1-nsig+i].Contains("m_{H}=300")) h->Add (h, 319.79533099-1.000); printf(" plotting sig i=%2i name=%20.20s file=%2i integral=%5.1f color=%2i\n", i,sampletitles[ntot-1-nsig+i].Data(),ntot+1-nsig+i,h->Integral(),hcolor); // create a white background around each line (helps readibility): TH1F *h1=h->Clone(); h1->SetStats(kFALSE); h1->SetLineWidth(6); h1->SetLineColor(0);h1->SetFillColor(0); h1->SetLineStyle(1); h1->SetFillStyle(0); h1->Draw("HIST,SAME"); // now draw the proper line: h->SetStats(kFALSE); h->SetLineWidth(6); h->SetLineColor(hcolor);h->SetFillColor(0); Int_t hlinestyle = params->GetValue(bSrcName+"LineStyle",1); h->SetLineStyle(hlinestyle); h->SetFillStyle(0); // finally, draw! h->Draw("HIST,SAME"); } // end of: drawing signal as separate lines // Data is special: // change the default size of the little bar at the end of the error bar here gStyle->SetEndErrorSize(3); // also, maybe don't display the error bars along the X axis: //gStyle->SetErrorX(0); // X error bars not displayed gStyle->SetErrorX(0.5); // X error bars have width of a bin // now set the rest h0->SetMarkerSize(2); // if there are too many points (>80), keep the marker size smaller if(h0->GetNbinsX()>=50) h0->SetMarkerSize(1); //if(h0->GetNbinsX()>=100) h0->SetMarkerSize(1); h0->SetLineWidth(3); h0->SetMarkerStyle(8); h0->SetMarkerColor(1); h0->Draw("E1,SAME"); // Print some comparison: //ostringstream basefactor; //basefactor << "Files." << nbkg+3 << "." << "Factor"; //TString timesfactor(basefactor.str().c_str()); //Double_t nprod = params->GetValue(timesfactor,1.000); //printf("Data Yield = %5.2f ; SumBkg = %5.2f ; SumBkg+Sig = %5.2f ; Data-SumBkg diff = %5.2f%% \n", // h0->Integral(),hbkg2->Integral,(hbkg2->Integral()+(signalhistos[0]->Integral()/nprod), // (h0->Integral()-hbkg2->Integral)*100./h0->Integral())); // // Print D0 and lumi: // TText *t1 = new TText(); t1->SetTextFont(62); t1->SetTextColor(1); t1->SetNDC(); t1->SetTextAlign(12); t1->SetTextSize(textSize); TString prelim="D\328 Preliminary"; if(oFileName.EndsWith(".eps")) { prelim="D\349 Preliminary L=3.7 fb^-1#"; } else if(oFileName.EndsWith(".gif")) { prelim="D\328 Preliminary L=3.7 fb^-1#"; } t1->DrawTextNDC(0.13,0.965,prelim.Data()); // a counter of how much text we have added from the top int nAddTextLines=0; // any additional text? for(int iText=1;iText<20;iText++) { ostringstream baseTextName; baseTextName << "Histo.AddText." << iText; TString bTextName(baseTextName.str().c_str()); if(params->Defined(bTextName)) { // we are adding a line of text TLatex *t2 = new TLatex(); t2->SetTextFont(62); t2->SetTextColor(13); t2->SetTextAlign(32); t2->SetNDC(); t2->SetTextSize(textSize); TString addText(params->GetValue(bTextName,".")); float x0=0.94; float y0=0.96-(nAddTextLines)*0.05; // check if the user specified an alternative location for the text if(params->Defined(bTextName+".X0")) x0=params->GetValue(bTextName+".X0",0.94); if(params->Defined(bTextName+".Y0")) y0=params->GetValue(bTextName+".Y0",0.8); if(params->Defined(bTextName+".TextSize")) t2->SetTextSize(params->GetValue(bTextName+".TextSize",textSize)); // and increment the counter keeping track of how much we added, // but only if the user didn't move the label around. if(!params->Defined(bTextName+".X0")) nAddTextLines++; printf("AddText %4.2f %4.2f %s\n",x0,y0,addText.Data()); t2->DrawLatex(x0,y0,addText.Data()); } }// end additional text // now draw the frame axis again so that we can see the tick marks frame->Draw("sameaxis"); // Legend: TString showLegend(params->GetValue("Histo.ShowLegend",".")); if( showLegend != "no" ){ float lgdxmin=.65, lgdxmax=.90, lgdymin=.50, lgdymax=.91; if(showLegend=="yes" || showLegend=="right") { } else if (showLegend=="left"){ lgdxmin=.16; lgdxmax=.42; } TLegend *lgd = new TLegend(lgdxmin,lgdymin,lgdxmax,lgdymax); // This line makes the legend transparent (not grey, ewwww!): lgd->SetBorderSize(0); lgd->SetTextSize(textSize*0.9);// 10% less size lgd->SetTextFont(62); lgd->SetFillColor(0); // Plot the legend in reverse order (but data goes first): NiceAddEntry(lgd,h0,params->GetValue("Files.1.Title","Data"),"PL"); for(Int_t i = nbkg; i>=0; i--){ TH1F * h = (TH1F*) addedhistos[i]; TString lgd_entry= sampletitles[i]; // sampletitles runs from 0 (firstbkg) to ntot-1 NiceAddEntry(lgd,h,lgd_entry.Data(),"F"); } for(Int_t i = nsig-1; i>=0; i--){ TH1F * h = (TH1F*) signalhistos[i]; TString lgd_entry = sampletitles[i+nbkg+1]; // sampletitles runs from 0 (firstbkg) to ntot-1 ostringstream basefactor; basefactor << "Files." << i+nbkg+3 << "." << "Factor"; TString timesfactor(basefactor.str().c_str()); Double_t nprod = params->GetValue(timesfactor,1.000); if (nprod != 1.0 ) lgd_entry.Form("%s x%2.0f",lgd_entry.Data(),nprod); //cout << i+nbkg+3 << " " << nprod << " " << lgd_entry.Data() << endl; NiceAddEntry(lgd,h,lgd_entry.Data(),"L"); } lgd->Draw("SAME"); }// show legend // Draw the KS: TLatex *ks = new TLatex(); ks->SetTextFont(62); ks->SetTextColor(1); TString ks_val = Form("KS = %3.2f",KS); ks->SetTextAlign(11); ks->SetTextSize(0.03); // ks->SetTextAngle(90); ks->DrawTextNDC(0.83,0.93,ks_val.Data()); TString chi2_val = Form("#chi^{2}/ndf = %3.1f",chi2ndf); ks->SetNDC(true); ks->DrawLatex(0.83,0.97,chi2_val.Data()); // // Voila! // }
void Unfold2(int algo= 3,bool useSpectraFromFile=0, bool useMatrixFromFile=0, int doToy = 0, int isMC = 0,char *spectraFileName = (char*)"pbpb_spectra_akPu3PF.root",double recoJetPtCut = 60,double trackMaxPtCut = 0, int nBayesianIter = 4, int doBjets=0) // algo 2 =akpu2 ; 3 =akpu3 ; 4 =akpu4 ;1 = icpu5 { gStyle->SetErrorX(0.5); gStyle->SetPaintTextFormat("3.2f"); gStyle->SetOptLogz(1); gStyle->SetPadRightMargin(0.13); gStyle->SetOptTitle(0); const float pplumi=5.3e9; const bool SavePlot=kTRUE; TH1::SetDefaultSumw2(); TH2::SetDefaultSumw2(); // input files char *fileNamePP_data = (char*)"/net/hidsk0001/d00/scratch/maoyx/pPb/Btag/CodeMatt/NewFormatV4_bFractionMCTemplate_pppp1_SSVHEat2.0FixCL0_bin_0_40_eta_0_2.root"; char *fileNamePbPb_data = (char*)"/net/hidsk0001/d00/scratch/maoyx/pPb/Btag/CodeMatt/AltBinningV6_bFractionMCTemplate_ppPbPb1_SSVHEat2.0FixCL0_bin_0_40_eta_0_2.root"; char *fileNamePP_mc = NULL; if(doBjets) fileNamePP_mc = (char*)"/net/hidsk0001/d00/scratch/kjung/histos/ppMC_ppReco_ak3PF_BjetTrig_noIPupperCut.root"; else fileNamePP_mc = (char*)"/net/hidsk0001/d00/scratch/kjung/histos//ppMC_ppReco_ak3PF_QCDjetTrig_noIPupperCut.root"; char *fileNamePbPb_mc = NULL; if(doBjets)fileNamePbPb_mc = (char*) "/net/hisrv0001/home/mnguyen/scratch/bTaggingOutput/ntuples/PbPbBMC_pt30by3_ipHICalibCentWeight_noTrig.root"; else fileNamePbPb_mc = (char*) "/net/hisrv0001/home/mnguyen/scratch/bTaggingOutput/ntuples/PbPbQCDMC_pt30by3_ipHICalibCentWeight_noTrig.root"; // grab ntuples TFile *infPbPb_mc = new TFile(fileNamePbPb_mc); TFile *infPP_mc = new TFile(fileNamePP_mc); // Output file TFile *pbpb_Unfo; if (isMC) pbpb_Unfo = new TFile(Form("pbpb_Unfo_%s_MC.root",algoName[algo]),"RECREATE"); else pbpb_Unfo = new TFile(Form("pbpb_Unfo_%s_jtpt%.0f_trk%.0f.root",algoName[algo],recoJetPtCut,trackMaxPtCut),"RECREATE"); // Histograms used by RooUnfold UnfoldingHistos *uhist[nbins_cent+1]; // Initialize Histograms for (int i=0;i<=nbins_cent;i++) uhist[i] = new UnfoldingHistos(i); // Initialize reweighting functions TCut dataSelection; TCut dataSelectionPP; TCut TriggerSelectionPP; TCut TriggerSelectionPbPb80; if(doBjets)dataSelection = "weight*(abs(refparton_flavorForB)==5&&abs(jteta)<2)"; else dataSelection = "weight*(abs(jteta)<2)"; if (isMC) cout<<"This is a MC closure test"<<endl; else cout<< "This is a data analysis"<<endl; // Setup jet data branches, basically the jet tree branches are assigned to this object when we loop over the events JetDataPbPb *dataPbPb = new JetDataPbPb(fileNamePbPb_mc,(char*)"nt"); // PbPb data JetDataPP *dataPP = new JetDataPP(fileNamePP_mc,(char*)"nt"); // pp data TFile *fSpectra(0); if (useSpectraFromFile||useMatrixFromFile){ fSpectra = new TFile(spectraFileName,"read"); } // Come back to the output file dir pbpb_Unfo->cd(); // Get Jet spectra from data file cout <<"Reading data..."<<endl; // This doesn't seem to be relevant for the moment -Matt /* TTree *tPbPbJet = (TTree*)infPbPb_mc->Get("nt"); TTree *tPPJet = (TTree*)infPP_mc->Get("nt"); TCanvas * cInput = new TCanvas("cInput","Input",800,400); cInput->Divide(2,1); cout <<"Spectra..."<<endl; for (int i=0;i<=nbins_cent;i++){ cout <<nbins_cent<<endl; TCut centCut = Form("bin<%.0f&&bin>=%.0f",boundaries_cent[i+1],boundaries_cent[i]); if (useSpectraFromFile) { uhist[i]->hMeas = (TH1F*)fSpectra->Get(Form("hMeas_cent%d",i)); } else { if (!isMC) { tPbPbJet->Project(Form("hMeas_cent%d",i),"jtptB", dataSelection&¢Cut&&TriggerSelectionPbPb80); } } if (useMatrixFromFile) { cout <<"Matrix"<<endl; uhist[i]->hMatrixFit = (TH2F*) fSpectra->Get(Form("hMatrixFit_cent%d",i)); uhist[i]->hMeasMatch = (TH1F*)((TH2F*) fSpectra->Get(Form("hMatrixFit_cent%d",i)))->ProjectionY(); uhist[i]->hMeasMatch->Divide(uhist[i]->hMeas); } else { uhist[i]->hMeasMatch = 0; } uhist[i]->hMeas->Draw(); } if (!isMC) tPPJet->Project(Form("hMeas_cent%d",nbins_cent),"jtpt",dataSelectionPP&&TriggerSelectionPP); */ cout <<"MC..."<<endl; TH1F *hCent = new TH1F("hCent","",nbins_cent,boundaries_cent); // Fill PbPb MC if (!useMatrixFromFile) { for (Long64_t jentry2=0; jentry2<dataPbPb->tJet->GetEntries();jentry2++) { dataPbPb->tJet->GetEntry(jentry2); // change when we switch to centrality binning int cBin = 0; //int cBin = hCent->FindBin(dataPbPb->bin)-1; /* if (cBin>=nbins_cent) continue; if (cBin==-1) continue; */ if ( dataPbPb->refpt < 0. ) continue; if ( dataPbPb->jteta > 2. || dataPbPb->jteta < -2. ) continue; if ( dataPbPb->refpt<0) dataPbPb->refpt=0; if (doBjets && fabs(dataPbPb->refparton_flavorForB)!=5) continue; if (doBjets&& dataPbPb->discr_ssvHighEff<2) continue; if (doBjets && dataPbPb->jtptB < recoJetPtCut) continue; if (!doBjets && dataPbPb->jtptA < recoJetPtCut) continue; //if ( dataPbPb->isTrig <1) continue; if(!doBjets)if(dataPbPb->refpt < 50 && dataPbPb->jtptA>120) continue; if(doBjets)if(dataPbPb->refpt < 50 && dataPbPb->jtptB>120) continue; if (!isMC||jentry2 % 2 == 1) { if(doBjets)uhist[cBin]-> hMatrix->Fill(dataPbPb->refpt,dataPbPb->jtptB,dataPbPb->weight); else uhist[cBin]-> hMatrix->Fill(dataPbPb->refpt,dataPbPb->jtptA,dataPbPb->weight); } if (jentry2 % 2 == 0) { uhist[cBin]-> hGen->Fill(dataPbPb->refpt,dataPbPb->weight); if(doBjets)uhist[cBin]-> hMeas->Fill(dataPbPb->jtptB,dataPbPb->weight); else uhist[cBin]-> hMeas->Fill(dataPbPb->jtptA,dataPbPb->weight); //uhist[cBin]-> hMeasJECSys->Fill(dataPbPb->jtpt*(1.+0.02/nbins_cent*(nbins_cent-i)),dataPbPb->weight); // FIXME!!!!!! i is supposed to be a loop over centrality !!!! if(doBjets)uhist[cBin]-> hMeasJECSys->Fill(dataPbPb->jtptB*(1.+0.02/nbins_cent*(nbins_cent-0)),dataPbPb->weight); else uhist[cBin]-> hMeasJECSys->Fill(dataPbPb->jtptA*(1.+0.02/nbins_cent*(nbins_cent-0)),dataPbPb->weight); } } //pp will just fill the last index of the centrality array // fill pp MC for (Long64_t jentry2=0; jentry2<dataPP->tJet->GetEntries();jentry2++) { dataPP->tJet->GetEntry(jentry2); if ( dataPP->refpt<0) continue; if ( dataPP->jteta > 2. || dataPP->jteta < -2. ) continue; if ( dataPP->refpt<0) dataPP->refpt=0; if ( doBjets && fabs(dataPP->refparton_flavorForB)!=5) continue; if ( doBjets && dataPP->discr_ssvHighEff<2) continue; if ( dataPP->jtpt < recoJetPtCut) continue; if (!isMC||jentry2 % 2 == 1) { uhist[nbins_cent]-> hMatrix->Fill(dataPP->refpt,dataPP->jtpt,dataPP->weight); } if (jentry2 % 2 == 0) { uhist[nbins_cent]-> hGen->Fill(dataPP->refpt,dataPP->weight); uhist[nbins_cent]-> hMeas->Fill(dataPP->jtpt,dataPP->weight); } } } cout <<"Response Matrix..."<<endl; TCanvas * cMatrix = new TCanvas("cMatrix","Matrix",800,400); cMatrix->Divide(2,1); for (int i=0;i<=nbins_cent;i++){ cMatrix->cd(i+1); if (!useMatrixFromFile) { TF1 *f = new TF1("f","[0]*pow(x+[2],[1])"); f->SetParameters(1e10,-8.8,40); for (int y=1;y<=uhist[i]->hMatrix->GetNbinsY();y++) { double sum=0; for (int x=1;x<=uhist[i]->hMatrix->GetNbinsX();x++) { if (uhist[i]->hMatrix->GetBinContent(x,y)<=1*uhist[i]->hMatrix->GetBinError(x,y)) { uhist[i]->hMatrix->SetBinContent(x,y,0); uhist[i]->hMatrix->SetBinError(x,y,0); } sum+=uhist[i]->hMatrix->GetBinContent(x,y); } for (int x=1;x<=uhist[i]->hMatrix->GetNbinsX();x++) { double ratio = 1; uhist[i]->hMatrix->SetBinContent(x,y,uhist[i]->hMatrix->GetBinContent(x,y)*ratio); uhist[i]->hMatrix->SetBinError(x,y,uhist[i]->hMatrix->GetBinError(x,y)*ratio); } } } uhist[i]->hResponse = (TH2F*)uhist[i]->hMatrix->Clone(Form("hResponse_cent%d",i)); for (int y=1;y<=uhist[i]->hResponse->GetNbinsY();y++) { double sum=0; for (int x=1;x<=uhist[i]->hResponse->GetNbinsX();x++) { if (uhist[i]->hResponse->GetBinContent(x,y)<=0*uhist[i]->hResponse->GetBinError(x,y)) { uhist[i]->hResponse->SetBinContent(x,y,0); uhist[i]->hResponse->SetBinError(x,y,0); } sum+=uhist[i]->hResponse->GetBinContent(x,y); } for (int x=1;x<=uhist[i]->hResponse->GetNbinsX();x++) { if (sum==0) continue; double ratio = uhist[i]->hMeas->GetBinContent(y)/sum; if (uhist[i]->hMeas->GetBinContent(y)==0) ratio = 1e-100/sum; } } uhist[i]->hResponseNorm = (TH2F*)uhist[i]->hMatrix->Clone(Form("hResponseNorm_cent%d",i)); for (int x=1;x<=uhist[i]->hResponseNorm->GetNbinsX();x++) { double sum=0; for (int y=1;y<=uhist[i]->hResponseNorm->GetNbinsY();y++) { if (uhist[i]->hResponseNorm->GetBinContent(x,y)<=0*uhist[i]->hResponseNorm->GetBinError(x,y)) { uhist[i]->hResponseNorm->SetBinContent(x,y,0); uhist[i]->hResponseNorm->SetBinError(x,y,0); } sum+=uhist[i]->hResponseNorm->GetBinContent(x,y); } for (int y=1;y<=uhist[i]->hResponseNorm->GetNbinsY();y++) { if (sum==0) continue; double ratio = 1./sum; uhist[i]->hResponseNorm->SetBinContent(x,y,uhist[i]->hResponseNorm->GetBinContent(x,y)*ratio); uhist[i]->hResponseNorm->SetBinError(x,y,uhist[i]->hResponseNorm->GetBinError(x,y)*ratio); } } uhist[i]->hResponse->Draw("col"); if (!useMatrixFromFile) uhist[i]->hMatrixFit = uhist[i]->hMatrix; uhist[i]->hMatrixFit->SetName(Form("hMatrixFit_cent%d",i)); } cMatrix->Update(); if (isMC==0) { // Use measured histogram from Matt & Kurt's file // PbPb file: TFile *infMatt = new TFile(fileNamePbPb_data); TH1F *hMattPbPb = NULL; if(doBjets) hMattPbPb = (TH1F*) infMatt->Get("hRawBData"); else hMattPbPb = (TH1F*) infMatt->Get("hIncJetsData"); divideBinWidth(hMattPbPb); // Need to match the binning carefully, please double check whenever you change the binning for (int i=1;i<=hMattPbPb->GetNbinsX();i++) { uhist[0]->hMeas->SetBinContent(i+uhist[0]->hMeas->FindBin(61)-1,hMattPbPb->GetBinContent(i)); uhist[0]->hMeas->SetBinError(i+uhist[0]->hMeas->FindBin(61)-1,hMattPbPb->GetBinError(i)); } // pp file: // The file name needs to be updated!!!!! TFile *infMattPP = new TFile(fileNamePP_data); TH1F *hMattPP = NULL; if(doBjets)hMattPP = (TH1F*) infMattPP->Get("hRawBData"); else hMattPP = (TH1F*) infMattPP->Get("hIncJetsData"); divideBinWidth(hMattPP); // Need to match the binning carefully, please double check whenever you change the binning for (int i=1;i<=hMattPP->GetNbinsX();i++) { uhist[nbins_cent]->hMeas->SetBinContent(i+uhist[nbins_cent]->hMeas->FindBin(61)-1,hMattPP->GetBinContent(i)); uhist[nbins_cent]->hMeas->SetBinError(i+uhist[nbins_cent]->hMeas->FindBin(61)-1,hMattPP->GetBinError(i)); } } pbpb_Unfo->cd(); cout << "==================================== UNFOLD ===================================" << endl; //char chmet[100]; // ======================= Reconstructed pp and PbPb spectra ========================================================= TCanvas * cPbPb = new TCanvas("cPbPb","Comparison",1200,600); cPbPb->Divide(2,1); cPbPb->cd(1); for (int i=0;i<=nbins_cent;i++) { cPbPb->cd(i+1)->SetLogy(); // Do Bin-by-bin TH1F *hBinByBinCorRaw = (TH1F*)uhist[i]->hResponse->ProjectionY(); TH1F *hMCGen = (TH1F*)uhist[i]->hResponse->ProjectionX(); // gen hBinByBinCorRaw->Divide(hMCGen); TF1 *f = new TF1("f","[0]+[1]*x"); hBinByBinCorRaw->Fit("f","LL ","",90,300); TH1F* hBinByBinCor = (TH1F*)hBinByBinCorRaw->Clone();//functionHist(f,hBinByBinCorRaw,Form("hBinByBinCor_cent%d",i)); delete hBinByBinCorRaw; delete hMCGen; uhist[i]->hRecoBinByBin = (TH1F*) uhist[i]->hMeas->Clone(Form("hRecoBinByBin_cent%d",i)); uhist[i]->hRecoBinByBin->Divide(hBinByBinCor); // Do unfolding //if (isMC) uhist[i]->hMeas = (TH1F*)uhist[i]->hMatrix->ProjectionY()->Clone(Form("hMeas_cent%d",i)); prior myPrior(uhist[i]->hMatrixFit,uhist[i]->hMeas,0); // myPrior.unfold(uhist[i]->hMeas,1); myPrior.unfold(uhist[i]->hMeas,nBayesianIter); TH1F *hPrior;//=(TH1F*) functionHist(fPow,uhist[i]->hMeas,Form("hPrior_cent%d",i)); hPrior = (TH1F*)uhist[i]->hGen->Clone("hPrior");//(TH1F*)uhist[i]->hMeas->Clone(Form("hPrior_cent%d",i)); removeZero(hPrior); bayesianUnfold myUnfoldingJECSys(uhist[i]->hMatrixFit,hPrior,0); myUnfoldingJECSys.unfold(uhist[i]->hMeasJECSys,nBayesianIter); bayesianUnfold myUnfoldingSmearSys(uhist[i]->hMatrixFit,hPrior,0); myUnfoldingSmearSys.unfold(uhist[i]->hMeasSmearSys,nBayesianIter); bayesianUnfold myUnfolding(uhist[i]->hMatrixFit,myPrior.hPrior,0); myUnfolding.unfold(uhist[i]->hMeas,nBayesianIter); cout <<"Unfolding bin "<<i<<endl; // Iteration Systematics for (int j=2;j<=40;j++) { bayesianUnfold myUnfoldingSys(uhist[i]->hMatrixFit,hPrior,0); myUnfoldingSys.unfold(uhist[i]->hMeas,j); uhist[i]->hRecoIterSys[j] = (TH1F*) myUnfoldingSys.hPrior->Clone(Form("hRecoRAA_IterSys%d_cent%d",j,i)); } uhist[i]->hReco = (TH1F*) uhist[i]->hRecoIterSys[nBayesianIter]->Clone(Form("Unfolded_cent%i",i)); uhist[i]->hRecoJECSys = (TH1F*) myUnfoldingJECSys.hPrior->Clone(Form("UnfoldedJeCSys_cent%i",i)); uhist[i]->hRecoSmearSys = (TH1F*) myUnfoldingSmearSys.hPrior->Clone(Form("UnfoldedSmearSys_cent%i",i)); uhist[i]->hRecoBinByBin->SetName(Form("UnfoldedBinByBin_cent%i",i)); if (doToy) { TCanvas *cToy = new TCanvas("cToy","toy",600,600); cToy->cd(); int nExp=1000; TH1F *hTmp[nbins_truth+1]; TH1F *hTmp2[nbins_truth+1]; for (int j=1;j<=nbins_truth;j++) { hTmp[j] = new TH1F(Form("hTmp%d",j),"",200,0,10.+uhist[i]->hReco->GetBinContent(j)*2); hTmp2[j] = new TH1F(Form("hTmp2%d",j),"",200,0,10.+uhist[i]->hRecoBinByBin->GetBinContent(j)*2); } for (int exp =0; exp<nExp; exp++) { TH1F *hToy = (TH1F*)uhist[i]->hMeas->Clone(); TH2F *hMatrixToy = (TH2F*)uhist[i]->hMatrixFit->Clone(); hToy->SetName("hToy"); if (exp%100==0) cout <<"Pseudo-experiment "<<exp<<endl; for (int j=1;j<=hToy->GetNbinsX();j++) { double value = gRandom->Poisson(uhist[i]->hMeas->GetBinContent(j)); hToy->SetBinContent(j,value); } for (int j=1;j<=hMatrixToy->GetNbinsX();j++) { for (int k=1;k<=hMatrixToy->GetNbinsY();k++) { double value = gRandom->Gaus(uhist[i]->hMatrixFit->GetBinContent(j,k),uhist[i]->hMatrixFit->GetBinError(j,k)); hMatrixToy->SetBinContent(j,k,value); } } prior myPriorToy(hMatrixToy,hToy,0.0); myPriorToy.unfold(hToy,1); bayesianUnfold myUnfoldingToy(hMatrixToy,myPriorToy.hPrior,0.0); myUnfoldingToy.unfold(hToy,nBayesianIter); TH1F *hRecoTmp = (TH1F*) myUnfoldingToy.hPrior->Clone(); for (int j=1;j<=hRecoTmp->GetNbinsX();j++) { hTmp[j]->Fill(hRecoTmp->GetBinContent(j)); } delete hToy; delete hRecoTmp; delete hMatrixToy; } TF1 *fGaus = new TF1("fGaus","[0]*TMath::Gaus(x,[1],[2])"); for (int j=1;j<=nbins_truth;j++) { f->SetParameters(hTmp[j]->GetMaximum(),hTmp[j]->GetMean(),hTmp[j]->GetRMS()); if (hTmp[j]->GetMean()>0) { hTmp[j]->Fit(fGaus,"LL Q "); hTmp[j]->Fit(fGaus,"LL Q "); uhist[i]->hReco->SetBinError(j,f->GetParameter(2)); } f->SetParameters(hTmp2[j]->GetMaximum(),hTmp2[j]->GetMean(),hTmp2[j]->GetRMS()); if (hTmp2[j]->GetMean()>0) { hTmp2[j]->Fit(fGaus,"LL Q "); hTmp2[j]->Fit(fGaus,"LL Q "); uhist[i]->hRecoBinByBin->SetBinError(j,f->GetParameter(2)); } delete hTmp[j]; delete hTmp2[j]; } cPbPb->cd(i+1); } uhist[i]->hMeas->SetMarkerStyle(20); uhist[i]->hMeas->SetMarkerColor(1); uhist[i]->hReco->SetMarkerStyle(24); uhist[i]->hReco->SetMarkerColor(2); uhist[i]->hReco->SetLineColor(2); uhist[i]->hReco->SetName(Form("hReco_cent%d",i)); uhist[i]->hReco->Draw(""); makeHistTitle(uhist[i]->hReco,"","Jet p_{T} (GeV/c)","dN_{jets} / dp_{T}"); uhist[i]->hReco->GetYaxis()->SetTitleOffset(1.3); uhist[i]->hReco->GetXaxis()->SetTitleOffset(1.2); uhist[i]->hGen->SetLineWidth(1); uhist[i]->hGen->SetLineColor(1); if(isMC)uhist[i]->hGen->Draw("hist same"); uhist[i]->hReco->Draw("same"); uhist[i]->hRecoBinByBin->SetMarkerStyle(28); uhist[i]->hRecoBinByBin->SetMarkerColor(4); uhist[i]->hRecoBinByBin->SetLineColor(4); uhist[i]->hRecoBinByBin->Draw("same"); uhist[i]->hReco->SetAxisRange(60,300); TH1F *hReproduced = (TH1F*)myUnfolding.hReproduced->Clone(Form("hReproduced_cent%d",i)); hReproduced->SetMarkerColor(4); hReproduced->SetMarkerStyle(24); uhist[i]->hMeas->Draw("same"); TLegend *leg = new TLegend(0.5,0.5,0.9,0.9); leg->SetBorderSize(0); leg->SetFillStyle(0); leg->AddEntry(uhist[i]->hMeas,"Measured","pl"); leg->AddEntry(uhist[i]->hReco,"Bayesian unfolded","pl"); leg->AddEntry(uhist[i]->hRecoBinByBin,"Bin-by-bin unfolded","pl"); if(isMC)leg->AddEntry(uhist[i]->hGen,"Generator level truth","l"); leg->Draw(); } cPbPb->Update(); // ======================= Unfolding closure in MC ========================================================= TCanvas * cRatio = new TCanvas("cRatio","Ratio",1200,600); TH1F * hReco[nbins_cent+1]; TH1F * hRecoBinByBin[nbins_cent+1]; TH1F * hMeas[nbins_cent+1]; TH1F * hGen[nbins_cent+1]; TLegend *leg[nbins_cent+1]; TLine *line = new TLine(60,1,250,1); line->SetLineStyle(2); line->SetLineWidth(2); for (int i=0;i<=nbins_cent;i++) { hReco[i] = (TH1F*)uhist[i]->hReco->Clone(Form("hReco_Cen%d", i)); hRecoBinByBin[i] = (TH1F*)uhist[i]->hRecoBinByBin->Clone(Form("hRecoBinByBin_Cen%d", i)); hMeas[i] = (TH1F*)uhist[i]->hMeas->Clone(Form("hMeas_Cen%d", i)); if(isMC) hGen[i] = (TH1F*)uhist[i]->hGen->Clone(Form("hGen_Cen%d", i)); } if(isMC){ cRatio->Divide(2,1); for (int i=0;i<=nbins_cent;i++) { hMeas[i]->Divide(hGen[i]); hRecoBinByBin[i]->Divide(hGen[i]); hReco[i]->Divide(hGen[i]); cRatio->cd(i+1); //hRecoPP->SetAxisRange(90,300,"X"); hReco[i]->SetAxisRange(0,2,"Y"); hReco[i]->SetMarkerStyle(24); hReco[i] ->SetLineColor(2); hReco[i] ->SetMarkerColor(2); hMeas[i]->SetMarkerStyle(20); hMeas[i]->SetLineColor(1); hMeas[i]->SetMarkerColor(1); hRecoBinByBin[i]->SetMarkerStyle(28); hRecoBinByBin[i]->SetLineColor(4); hRecoBinByBin[i]->SetMarkerColor(4); makeHistTitle(hReco[i],"","Jet p_{T} (GeV/c)","Reco / Truth"); hReco[i]->GetYaxis()->SetTitleOffset(1.4); hReco[i]->GetXaxis()->SetTitleOffset(1.2); hReco[i]->Draw(""); hRecoBinByBin[i]->Draw("same"); hMeas[i]->Draw("same"); line->Draw(); leg[i] = myLegend(0.52,0.65,0.85,0.9); leg[i]->AddEntry(hReco[i],"Bayesian","pl"); leg[i]->AddEntry(hRecoBinByBin[i],"Bin-by-bin","pl"); leg[i]->AddEntry(hMeas[i],"no unfolding","pl"); leg[i]->Draw(); putCMSPrel(0.2,0.83,0.06); drawText("Anti-k_{T} Particle Flow Jets R = 0.3",0.2,0.23,20); drawText("CMS Simulation",0.6,0.4,22); drawText("| #eta | <2 ",0.6,0.31,22); } } else { hMeas[nbins_cent]->Scale(1./CorFac[6]/5.3e9); hRecoBinByBin[nbins_cent]->Scale(1./CorFac[6]/5.3e9); hReco[nbins_cent]->Scale(1./CorFac[6]/5.3e9); cRatio->cd(1); for (int i=0;i<nbins_cent;i++) { hMeas[i] ->Scale(1./CorFac[i]/1.0908e9/TAA[i]); hRecoBinByBin[i] ->Scale(1./CorFac[i]/1.0908e9/TAA[i]); hReco[i] ->Scale(1./CorFac[i]/1.0908e9/TAA[i]); hMeas[i]->Divide(hMeas[nbins_cent]); hRecoBinByBin[i]->Divide(hRecoBinByBin[nbins_cent]); hReco[i]->Divide(hReco[nbins_cent]); hReco[i]->SetAxisRange(0,2,"Y"); hReco[i]->SetMarkerStyle(24); hReco[i] ->SetLineColor(2); hReco[i] ->SetMarkerColor(2); hMeas[i]->SetMarkerStyle(20); hMeas[i]->SetLineColor(1); hMeas[i]->SetMarkerColor(1); hRecoBinByBin[i]->SetMarkerStyle(28); hRecoBinByBin[i]->SetLineColor(4); hRecoBinByBin[i]->SetMarkerColor(4); // if(i==0){ makeHistTitle(hReco[i],"","Jet p_{T} (GeV/c)","Spectra Ratio"); hReco[i]->GetYaxis()->SetTitleOffset(1.4); hReco[i]->GetXaxis()->SetTitleOffset(1.2); hReco[i]->Draw(""); leg[i] = myLegend(0.52,0.65,0.85,0.9); leg[i]->AddEntry(hReco[i],"Bayesian","pl"); leg[i]->AddEntry(hRecoBinByBin[i],"Bin-by-bin","pl"); leg[i]->AddEntry(hMeas[i],"no unfolding","pl"); leg[i]->Draw(); // } // else { hReco[i]->Draw("same"); hRecoBinByBin[i]->Draw("same"); hMeas[i]->Draw("same"); // } } line->Draw(); putCMSPrel(0.2,0.83,0.06); drawText(Form("#intL dt = %.f #mub^{-1}",150.),0.2,0.78,22); drawText("Anti-k_{T} Particle Flow Jets R = 0.3",0.2,0.73,20); drawText("| #eta | <2 ",0.6,0.69,22); } cRatio->Update(); pbpb_Unfo->Write(); SysData systematics; // Iteration systematics TCanvas *cIterSys = new TCanvas("cIterSys","IterSys",1200,600); cIterSys->Divide(2,1); cIterSys->cd(2); TH1F *hRecoIterSysPP[100]; TH1F *hRebinPP_tmp = rebin(uhist[nbins_cent]->hReco, (char*)"hRebinPP_tmp"); TLegend *legBayesianIterPP = myLegend(0.4,0.7,0.9,0.9); legBayesianIterPP->AddEntry("","PP",""); for (int j=2;j<7;j++) { hRecoIterSysPP[j] = rebin(uhist[nbins_cent]->hRecoIterSys[j],Form("hRecoIterSysPP_IterSys%d",j)); hRecoIterSysPP[j]->SetLineColor(colorCode[j-2]); hRecoIterSysPP[j]->SetMarkerColor(colorCode[j-2]); hRecoIterSysPP[j]->Divide(hRebinPP_tmp); if (j==2){ // makeHistTitle(hRecoIterSysPP[j],(char*)"",(char*)"Jet p_{T} (GeV/c)",(char*)"Ratio (Unfolded / Nominal)"); makeHistTitle(hRecoIterSysPP[j],"","Jet p_{T} (GeV/c)","Ratio (Unfolded / Nominal)"); hRecoIterSysPP[j]->SetTitleOffset(1.3,"Y"); hRecoIterSysPP[j]->SetTitleOffset(1.2,"X"); hRecoIterSysPP[j]->SetAxisRange(0,2,"Y"); hRecoIterSysPP[j]->Draw(); } else { hRecoIterSysPP[j]->Draw("same"); } checkMaximumSys(systematics.hSysIter[nbins_cent],hRecoIterSysPP[j],0,1.1); legBayesianIterPP->AddEntry(hRecoIterSysPP[j],Form("Iteration %d",j),"pl"); } legBayesianIterPP->Draw(); line->Draw(); drawEnvelope(systematics.hSysIter[nbins_cent],(char*)"hist same"); cIterSys->cd(1); TH1F *hRecoIterSysPbPb[100]; TH1F *hRebinPbPb_tmp = rebin(uhist[0]->hReco, (char*)"hRebinPbPb_tmp"); TLegend *legBayesianIterPbPb = myLegend(0.4,0.7,0.9,0.9); legBayesianIterPbPb->AddEntry("","PbPb",""); for (int j=2;j<7;j++) { hRecoIterSysPbPb[j] = rebin(uhist[0]->hRecoIterSys[j],Form("hRecoIterSysPbPb_IterSys%d",j)); hRecoIterSysPbPb[j]->SetLineColor(colorCode[j-2]); hRecoIterSysPbPb[j]->SetMarkerColor(colorCode[j-2]); hRecoIterSysPbPb[j]->Divide(hRebinPbPb_tmp); if (j==2){ // makeHistTitle(hRecoIterSysPbPb[j],(char*)"",(char*)"Jet p_{T} (GeV/c)",(char*)"Ratio (Unfolded / Nominal)"); makeHistTitle(hRecoIterSysPbPb[j],"","Jet p_{T} (GeV/c)","Ratio (Unfolded / Nominal)"); hRecoIterSysPbPb[j]->SetTitleOffset(1.3,"Y"); hRecoIterSysPbPb[j]->SetTitleOffset(1.2,"X"); hRecoIterSysPbPb[j]->SetAxisRange(0,2,"Y"); hRecoIterSysPbPb[j]->Draw(); } else { hRecoIterSysPbPb[j]->Draw("same"); } checkMaximumSys(systematics.hSysIter[0],hRecoIterSysPbPb[j],0,1.1); legBayesianIterPbPb->AddEntry(hRecoIterSysPbPb[j],Form("Iteration %d",j),"pl"); } legBayesianIterPbPb->Draw(); line->Draw(); drawEnvelope(systematics.hSysIter[0],(char*)"hist same"); cIterSys->Update(); TString data ; if(isMC) data="MC"; else data="Data"; TString anaType ; if(doBjets) anaType="Bjet"; else anaType="Inclusive"; if(SavePlot){ cMatrix->SaveAs(Form("plots/%s%s%sResponseMatrix.gif", data.Data(), anaType.Data(), algoName[algo])); cPbPb->SaveAs(Form("plots/%s%s%sJetSpectra.gif", data.Data(), anaType.Data(), algoName[algo])); cRatio->SaveAs(Form("plots/%s%s%sJetRatio.gif", data.Data(), anaType.Data(), algoName[algo])); cIterSys->SaveAs(Form("plots/%s%s%sIterationSys.gif", data.Data(), anaType.Data(), algoName[algo])); } }
void fit_h_Xm_extended() { TCanvas* c1; c1 = new TCanvas("c1","",1440,900); TFile *f; int mass[13]={600,800,1000,1200,1400,1600,1800,2000,2500,3000,3500,4000,4500}; float width [4]={0.05,0.1,0.2,0.3}; string widthdata[4]={"0.05","0.1","0.2","0.3"}; //for(int i=0 ;i<4;i++){ //for(int j=0) //} for(int i=0;i<4;i++){ for(int j=0;j<13;j++){ f = TFile::Open(Form("offshell_root_files/Zprime_Zh_Zlephbb_w%s_M%d.root",widthdata[i].data(),mass[j])); TH1F* h =(TH1F*) f->FindObjectAny("h_Xm_extended"); int bmin=0,bmax=0; for (int k=1;k<25001;k++){ bmin=k; if (h->GetBinContent(k)!=0) break; } for (int k=25000;k>0;k--){ bmax=k; if (h->GetBinContent(k)!=0) break; } if((bmin-300)<0)bmin=0; else bmin=bmin-300; bmax=bmax+bmax/10; cout <<bmin<<","<<bmax<<endl; //gStyle->SetOptFit(111111); //gStyle->SetStatW (0.1); //gStyle->SetStatH (0.1); //gStyle->SetStatX (0.941349); //gStyle->SetStatY (0.912491); fiveWidthLow= mass[j] -5* (width [i])*mass[j]; fiveWidthUp= mass[j] +5* (width [i])*mass[j]; float inte=h->Integral(fiveWidthLow,fiveWidthUp); inte=inte*100/(bmax-bmin); //h->Rebin((bmax-bmin)/100); int massfix=200; if(i>1&&j>8)massfix=400; if(i>2&&j>9)massfix=500; float widthfix=0; if(i>2&&j>9)widthfix=0.1; TF1* f1 = new TF1("f1","[2]*TMath::BreitWigner(x,[0],[1])"); f1->SetNpx(2500); f1->SetParameters(mass[j],width [i]*mass[j],h->Integral()); //f1->SetLineColor(3); h->GetXaxis()->SetRangeUser(bmin,bmax); h->SetTitle(Form("offshell_root_files/Zprime_Zh_Zlephbb_w%s_M%d.root",widthdata[i].data(),mass[j])); TH1F* h2=(TH1F*) h->Clone("h2"); //h->Fit(f1,"","",fiveWidthLow,fiveWidthUp); //h->Fit(f1,"L"); TF1* f2 = new TF1("f2",fline,bmin,bmax,3); if(j>2)inte=h->Integral(); f2->SetParameters(mass[j],width [i]*mass[j],h->Integral()); f2->SetNpx(2500); //f2->SetLineColor(3); //h2->Fit(f2); //TF1* fleft = new TF1("fleft","[2]*TMath::BreitWigner(x,[0],[1])"); //TF1 *fleft = new TF1("fleft","[2]*TMath::BreitWigner(x,[0],[1])",bmin,bmax,3); //fleft->SetParameters(f2->GetParameters()); //fleft->SetLineColor(3); h->SetMinimum(0); h->Draw(); //fleft->Draw(); //h2->Draw("same"); //f1->Draw(); if (i==0 && j==0)c1->Print("fit_h_Xm_extended.pdf("); else if (i==3 && j==12)c1->Print("fit_h_Xm_extended.pdf)"); else c1->Print("fit_h_Xm_extended.pdf"); c1->SaveAs(Form("png/Zprime_Zh_Zlephbb_w%s_M%d.png",widthdata[i].data(),mass[j])); //c1->Print("fit_h_Xm_extended.pdf)"); } } }
//------------------------------------------------------------------------------ // DrawHistogram //------------------------------------------------------------------------------ void DrawHistogram(TString hname, TString xtitle, Int_t ngroup = -1, Int_t precision = 1, TString units = "NULL", Double_t xmin = -999, Double_t xmax = 999, Bool_t moveOverflow = true) { //TCanvas* canvas = new TCanvas(hname, hname, 550, 720); TCanvas* canvas = new TCanvas(hname, hname, 800, 800); TPad* pad1 = new TPad("pad1", "pad1", 0, 0.3, 1, 1.0); TPad* pad2 = new TPad("pad2", "pad2", 0, 0.0, 1, 0.3); pad1->SetTopMargin (0.08); pad1->SetBottomMargin(0.02); pad1->Draw(); pad2->SetTopMargin (0.08); pad2->SetBottomMargin(0.35); pad2->Draw(); //---------------------------------------------------------------------------- // pad1 //---------------------------------------------------------------------------- pad1->cd(); pad1->SetLogy(_setLogy); THStack* hstack = new THStack(hname, hname); TH1F* hist[nProcesses]; //Save histograms to root file TFile* outfile; //TString fname = Form("files/%s_%djet.root", hname.Data(),_njet); TString fname = "files/0jet_"+hname+".root"; if(_njet==1) fname = "files/1jet_"+hname+".root"; outfile = new TFile(fname, "create"); TH1F* data; TH1F* top; TH1F* tW; TH1F* WW; TH1F* WZ; TH1F* ZZ; TH1F* Wg; TH1F* WgSMu; TH1F* WgSEl; TH1F* Wjets; TH1F* Zjets; TH1F* DYtau; TH1F* Zgamma; TH1F* ggH; for (UInt_t ip=0; ip<nProcesses; ip++) { hist[ip] = (TH1F*)input[ip]->Get(hname); hist[ip]->SetName(hname + process[ip]); hist[ip]->SetTitle(""); if(ip == iData) data = (TH1F*)hist[iData]->Clone("Data"); //data -> Sumw2(); if(ip == itt) top = (TH1F*)hist[itt]->Clone("top"); //top -> Sumw2(); if(ip == itW) tW = (TH1F*)hist[itW]->Clone("tW"); //tW -> Sumw2(); if(ip == iWW) WW = (TH1F*)hist[iWW]->Clone("WW"); //WW -> Sumw2(); if(ip == iWZ) WZ = (TH1F*)hist[iWZ]->Clone("WZ"); //VV -> Sumw2(); if(ip == iZZ) ZZ = (TH1F*)hist[iZZ]->Clone("ZZ"); //ZZ -> Sumw2(); if(ip == iWg) Wg = (TH1F*)hist[iWg]->Clone("Wg"); //Wg -> Sumw2(); if(ip == iWgSMu){ WgSMu = (TH1F*)hist[iWgSMu]->Clone("WgSMu"); //WgSMu -> Sumw2(); hist[iWgSMu]->Scale(1.5); } if(ip == iWgSEl){ WgSEl = (TH1F*)hist[iWgSEl]->Clone("WgSEl"); //WgSel -> Sumw2(); hist[iWgSEl]->Scale(1.5); //WgSel -> Sumw2(); } if(ip == iWj) Wjets = (TH1F*)hist[iWj]->Clone("W+jets"); //Wjets -> Sumw2(); if(ip == iDY) Zjets = (TH1F*)hist[iDY]->Clone("Z+jets"); //Zjets -> Sumw2(); if(ip == iDYtau) DYtau = (TH1F*)hist[iDYtau]->Clone("DYtau"); //DYtau -> Sumw2(); if(ip == iZgamma) Zgamma = (TH1F*)hist[iZgamma]->Clone("Zgamma"); //Zgamma -> Sumw2(); if(ip == iH125) ggH = (TH1F*)hist[iH125]->Clone("ggH"); //ggH -> Sumw2(); if (moveOverflow) MoveOverflowBins (hist[ip], xmin, xmax); else ZeroOutOfRangeBins(hist[ip], xmin, xmax); if (ngroup > 0) hist[ip]->Rebin(ngroup); if (ip == iWg) { //hist[ip]->Scale(0.01); } if (ip == iData) { hist[ip]->SetMarkerStyle(kFullCircle); } else { hist[ip]->SetFillColor(color[ip]); hist[ip]->SetFillStyle(1001); hist[ip]->SetLineColor(color[ip]); if (_dataDriven && ip == itt) hist[ip]->Scale(ttScale[_njet]); if (_dataDriven && ip == itW) hist[ip]->Scale(tWScale[_njet]); if (_dataDriven && ip == iWW) hist[ip]->Scale(WWScale[_njet]); if (_dataDriven && ip == iDY) hist[ip]->Scale(ZjScale[_njet]); if (_dataDriven && ip == iDYtau) hist[ip]->Scale(ZjScale[_njet]); if( ip != iZZ ) hstack->Add(hist[ip]);//TODO something wrong with ZZ } } if (_dataDriven) { top->Scale(ttScale[_njet]); tW->Scale(tWScale[_njet]); WW->Scale(WWScale[_njet]); Zjets->Scale(ZjScale[_njet]); DYtau->Scale(ZjScale[_njet]); } top ->Add(tW); //VV ->Add(ZZ); //VV ->Add(Wg); //Zjets->Add(DYtau); //Zjets->Add(Zgamma); data -> Write(); top -> Write(); WW -> Write(); //VV -> Write(); //Wjets -> Write(); //Zjets -> Write(); ggH -> Write(); outfile->Close(); // All MC //---------------------------------------------------------------------------- TH1F* allmc = (TH1F*)hist[iData]->Clone("allmc"); allmc->SetFillColor (kGray+2); allmc->SetFillStyle ( 3345); allmc->SetLineColor (kGray+2); allmc->SetMarkerColor(kGray+2); allmc->SetMarkerSize ( 0); for (UInt_t ibin=1; ibin<=allmc->GetNbinsX(); ibin++) { Double_t binValue = 0; Double_t binError = 0; for (UInt_t ip=0; ip<nProcesses; ip++) { if (ip == iData) continue; if (ip == iZZ) continue; Double_t binContent = hist[ip]->GetBinContent(ibin); binValue += binContent; binError += (hist[ip]->GetBinError(ibin) * hist[ip]->GetBinError(ibin)); //We need to calculate systematic uncertainty for ggH case // if (_dataDriven) // binError += (systError[ip]*binContent * systError[ip]*binContent); } binError = sqrt(binError); allmc->SetBinContent(ibin, binValue); allmc->SetBinError (ibin, binError); } // Axis labels //------------------------------------------------------------------ TAxis* xaxis = hist[iData]->GetXaxis(); TAxis* yaxis = hist[iData]->GetYaxis(); TString ytitle = Form("entries / %s.%df", "%", precision); xaxis->SetTitle(xtitle); yaxis->SetTitle(Form(ytitle.Data(), hist[iData]->GetBinWidth(0))); yaxis->SetTitleOffset(1.6); if (!units.Contains("NULL")) { xaxis->SetTitle(Form("%s [%s]", xaxis->GetTitle(), units.Data())); yaxis->SetTitle(Form("%s %s", yaxis->GetTitle(), units.Data())); } // Draw //-------------------------------------------------------------------- xaxis->SetRangeUser(xmin, xmax); hist[iData]->Draw("ep"); hstack ->Draw("hist,same"); allmc ->Draw("e2,same"); hist[iData]->Draw("ep,same"); // Adjust scale //---------------------------------------------------------------------------- Float_t theMax = GetMaximumIncludingErrors(hist[iData], xmin, xmax); Float_t theMaxMC = GetMaximumIncludingErrors(allmc, xmin, xmax); if (theMaxMC > theMax) theMax = theMaxMC; if (pad1->GetLogy()) { theMax = TMath::Power(10, TMath::Log10(theMax) + 2.7); hist[iData]->SetMinimum(0.05); } else theMax *= 1.55; hist[iData]->SetMaximum(theMax); // Legend //---------------------------------------------------------------------- Double_t x0 = 0.720; Double_t y0 = 0.834; Double_t yoffset = 0.048; Double_t delta = yoffset + 0.001; Double_t ndelta = 0; Double_t YieldTop = Yield(hist[itt]) + Yield(hist[itW]); Double_t YieldWZ = Yield(hist[iWZ]); Double_t YieldVV = Yield(hist[iWZ]) + Yield(hist[iZZ]) + Yield(hist[iWg]); //Double_t YieldZJets = Yield(hist[iDY]) + Yield(hist[iDYtau]); Double_t YieldZJets = Yield(hist[iDY]) + Yield(hist[iDYtau]) + Yield(hist[iZgamma]); DrawLegend(x0 - 0.49, y0 - ndelta, hist[iData], Form(" data (%.0f)", Yield(hist[iData])), "lp", 0.03, 0.2, yoffset); ndelta += delta; //DrawLegend(x0 - 0.23, y0 - ndelta, hist[itt], Form(" tt (%.0f)", Yield(hist[itt])), "f", 0.03, 0.2, yoffset); ndelta += delta; //DrawLegend(x0 - 0.23, y0 - ndelta, hist[itW], Form(" tW (%.0f)", Yield(hist[itW])), "f", 0.03, 0.2, yoffset); ndelta += delta; //DrawLegend(x0 - 0.49, y0 - ndelta, allmc, Form(" all (%.0f)", Yield(allmc)), "f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWW], Form(" WW (%.0f)", Yield(hist[iWW])), "f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWZ], Form(" WZ (%.0f)", Yield(hist[iWZ])), "f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWg], Form(" Wg (%.0f)", Yield(hist[iWg])), "f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWgSMu], Form(" Wg*Mu (%.0f)", Yield(hist[iWgSMu])), "f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWgSEl], Form(" Wg*El (%.0f)", Yield(hist[iWgSEl])), "f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWj], Form(" W+jets (%.0f)",Yield(hist[iWj])), "f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.49, y0 - ndelta, hist[iZZ], Form(" ZZ (%.0f)", Yield(hist[iZZ])), "f", 0.03, 0.2, yoffset); ndelta += delta; ndelta = 0; DrawLegend(x0 - 0.23, y0 - ndelta, hist[iDY], Form(" DY (%.0f)", Yield(hist[iDY])), "f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.23, y0 - ndelta, hist[iDYtau], Form(" DYtau (%.0f)", Yield(hist[iDYtau])),"f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.23, y0 - ndelta, hist[iZgamma],Form(" Zg (%.0f)", Yield(hist[iZgamma])),"f", 0.03, 0.2, yoffset); ndelta += delta; //DrawLegend(x0 - 0.23, y0 - ndelta, hist[iDY], Form(" Z+jets (%.0f)", YieldZJets), "f", 0.03, 0.2, yoffset); ndelta += delta; //DrawLegend(x0 - 0.23, y0 - ndelta, hist[iH125], Form(" Higgs (%.0f)", Yield(hist[iH125])), "f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.23, y0 - ndelta, hist[iH125], Form(" ggH (%.0f)", Yield(hist[iH125])), "f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.23, y0 - ndelta, hist[itt], Form(" tt (%.0f)", Yield(hist[itt])), "f", 0.03, 0.2, yoffset); ndelta += delta; DrawLegend(x0 - 0.23, y0 - ndelta, hist[itW], Form(" tW (%.0f)", Yield(hist[itW])), "f", 0.03, 0.2, yoffset); ndelta += delta; // Additional titles //---------------------------------------------------------------------------- //TString channelLabel = "ee/#mu#mu/e#mu/#mue"; TString channelLabel = ""; //if (_channel == "EE") channelLabel = "ee"; //if (_channel == "MuMu") channelLabel = "#mu#mu"; //if (_channel == "EMu") channelLabel = "e#mu"; //if (_channel == "MuE") channelLabel = "#mue"; //if (_channel == "SF") channelLabel = "ee/#mu#mu"; //if (_channel == "OF") channelLabel = "e#mu/#mue"; channelLabel += Form(" %d", _njet); if (_njet == 0) channelLabel += "-jets"; if (_njet == 1) channelLabel += "-jet"; if (_njet >= 2) channelLabel += "-jets"; double nBin; double binWidth; nBin = allmc->GetSize(); nBin -=2; binWidth = allmc->GetBinWidth(2); int Z1bin=70/binWidth; int Z2bin=110/binWidth; cout<<"number of bin: "<<nBin<<endl; cout<<"Z bin1: "<<Z1bin<<" Z bin2: "<<Z2bin<<endl; double nMcZ, nDataZ; nMcZ = allmc->Integral(Z1bin,Z2bin); nDataZ = hist[iData]->Integral(Z1bin,Z2bin); double effiCorr; effiCorr=nDataZ/nMcZ; cout<<"efficiency correction factor: "<<effiCorr<<endl; double nMcGstar, nDataGstar, nMcGamma; nMcGstar = hist[iWgSMu]->Integral(1,2); nMcGamma = hist[iWg]->Integral(1,2); //nMcGstar = allmc->Integral(1,2); nMcGstar *= effiCorr; nMcGamma *= effiCorr; nDataGstar = hist[iData]->Integral(1,2); double Kfactor; double KfactorErr; nDataGstar -= nMcGamma; Kfactor = nDataGstar/nMcGstar; KfactorErr =Kfactor* TMath::Sqrt(nDataGstar/nDataGstar/nDataGstar + nMcGstar/nMcGstar/nMcGstar); KfactorErr += 0.1; cout<<"Kfactor: "<<Kfactor<<"+"<<KfactorErr<<endl; //DrawTLatex(0.185, 0.975, 0.05, 13, channelLabel.Data(),""); DrawTLatex(0.940, 0.983, 0.05, 33, Form("L = %.1f fb^{-1}", _luminosity/1e3),""); DrawTLatex(0.45, 0.48, 0.04, 13, Form("K factor (Data/Wg*) = %.2f #pm %.2f", Kfactor, KfactorErr ),""); DrawTLatex(0.45, 0.43, 0.04, 13, Form("0< InvM(#mu^{+}#mu^{-}) <4 GeV"),""); //---------------------------------------------------------------------------- // pad2 //---------------------------------------------------------------------------- pad2->cd(); TH1F* ratio = (TH1F*)hist[iData]->Clone("ratio"); TH1F* uncertainty = (TH1F*)allmc->Clone("uncertainty"); for (UInt_t ibin=1; ibin<=ratio->GetNbinsX(); ibin++) { Double_t mcValue = allmc->GetBinContent(ibin); Double_t mcError = allmc->GetBinError (ibin); Double_t dtValue = ratio->GetBinContent(ibin); Double_t dtError = ratio->GetBinError (ibin); Double_t ratioValue = (mcValue > 0) ? dtValue/mcValue : 0.0; Double_t ratioError = (mcValue > 0) ? dtError/mcValue : 0.0; Double_t uncertaintyError = (mcValue > 0) ? mcError/mcValue : 0.0; ratio->SetBinContent(ibin, ratioValue); ratio->SetBinError (ibin, ratioError); uncertainty->SetBinContent(ibin, 1.0); uncertainty->SetBinError (ibin, uncertaintyError); } TAxis* uaxis = (TAxis*)uncertainty->GetXaxis(); uaxis->SetRangeUser(xmin, xmax); uncertainty->Draw("e2"); ratio ->Draw("ep,same"); uncertainty->GetYaxis()->SetRangeUser(0, 2.5); // Save //---------------------------------------------------------------------- pad2->cd(); SetAxis(uncertainty, hist[iData]->GetXaxis()->GetTitle(), "data / prediction", 0.10, 0.8); pad1->cd(); SetAxis(hist[iData], "", hist[iData]->GetYaxis()->GetTitle(), 0.05, 1.6); canvas->cd(); TString suffixLogy = (_setLogy) ? "_Log" : "_Lin"; canvas->SaveAs(Form("%s/%s%s.%s", _output.Data(), hname.Data(), suffixLogy.Data(), _format.Data())); }
int main(int argc, char** argv) { //Check if all nedeed arguments to parse are there if(argc != 2) { std::cerr << ">>>>> analysis.cpp::usage: " << argv[0] << " configFileName" << std::endl ; return 1; } // Parse the config file parseConfigFile (argv[1]) ; std::string treeName = gConfigParser -> readStringOption("Input::treeName"); std::string inputFile = gConfigParser -> readStringOption("Input::inputFile"); double inputXSection = gConfigParser -> readDoubleOption("Input::inputXSection"); int entryMAX = gConfigParser -> readIntOption("Input::entryMAX"); int entryMIN = gConfigParser -> readIntOption("Input::entryMIN"); int entryMOD = gConfigParser -> readIntOption("Input::entryMOD"); std::cout << ">>>>> input::entryMIN " << entryMIN << std::endl; std::cout << ">>>>> input::entryMAX " << entryMAX << std::endl; std::cout << ">>>>> input::entryMOD " << entryMOD << std::endl; int dataFlag = 0; if (inputXSection == -1) dataFlag = 1; //==== it's a data sample!!! std::cerr << ">>>>> input:: --- dataFlag " << dataFlag << std::endl; // define map with events std::map<std::pair<int,std::pair<int,int> >,int> eventsMap; int nStepToDo = 1000; try { nStepToDo = gConfigParser -> readIntOption("Input::nStepToDo"); } catch (char const* exceptionString){ std::cerr << " exception = " << exceptionString << std::endl; nStepToDo = 1000; } std::cout << ">>>>> input::nStepToDo " << nStepToDo << std::endl; // Open ntple TChain* chain = new TChain(treeName.c_str()); chain->Add(inputFile.c_str()); treeReader reader((TTree*)(chain)); bool debug = false; try { debug = gConfigParser -> readBoolOption("Input::debug"); } catch (char const* exceptionString){ std::cerr << " exception = " << exceptionString << std::endl; } std::cout << ">>>>> input::debug " << debug << std::endl; ///****************** ///**** Triggers **** std::vector<std::string> HLTVector; try { HLTVector = gConfigParser -> readStringListOption("Options::HLTVector"); } catch (char const* exceptionString){ std::cerr << " exception = " << exceptionString << std::endl; } std::cout << ">>>>> Options::HLTVector size = " << HLTVector.size() << std::endl; std::cout << ">>>>> >>>>> "; for (int iHLT = 0; iHLT < HLTVector.size(); iHLT++){ std::cout << " " << HLTVector.at(iHLT) << ", "; } std::cout << std::endl; ///**************************** ///**** DATA JSON file **** std::string inFileNameJSON; try { inFileNameJSON = gConfigParser -> readStringOption("Input::inFileNameJSON"); } catch (char const* exceptionString){ std::cerr << " exception = " << exceptionString << std::endl; } std::cout << ">>>>> Input::inFileNameJSON " << inFileNameJSON << std::endl; std::map<int, std::vector<std::pair<int, int> > > jsonMap; if( dataFlag == 1 ) { jsonMap = readJSONFile(inFileNameJSON); } ///---- Efficiency preselections ---- std::string histoNameEvents = gConfigParser -> readStringOption("Input::histoNameEvents"); std::cout << ">>>>> Input::inputFile " << inputFile << std::endl; std::cout << ">>>>> Input::inputXSection " << inputXSection << std::endl; std::cout << ">>>>> Input::histoNameEvents " << histoNameEvents << std::endl; // Open ntples TFile File(inputFile.c_str()) ; TH1F* histoEvents = (TH1F*) File.Get(TString(histoNameEvents.c_str())); ///---------------------- ///---- Preselection ---- ///~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ///==== only retrocompatibility ==== ///================================= double lepton_efficiency = 1; double jet_efficiency = 1; double eff_Channel_Filter = 1; double preselection_efficiency = 1.; ///~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ///~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ///~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ///------------------- ///---- selection ---- std::string outFileName = gConfigParser -> readStringOption("Output::outFileName"); std::cout << ">>>>> Output::outFileName " << outFileName << std::endl; int nStep = 10; ///==== number of steps in the analysis int numEntriesBefore; // define variable container Variables vars; InitializeTree(vars, outFileName); InitializeTreeTrigger(vars, HLTVector, reader); vars.XSection = inputXSection; vars.dataFlag = dataFlag; ///~~~~ 0 = MC 1 = DATA if (entryMAX == -1) entryMAX = reader.GetEntries(); else if (reader.GetEntries() < entryMAX) entryMAX = reader.GetEntries(); numEntriesBefore = entryMAX - entryMIN; if (histoEvents) preselection_efficiency = numEntriesBefore / (1. * histoEvents->GetBinContent(1)); else preselection_efficiency = 1; vars.numEntriesBefore = numEntriesBefore; vars.preselection_efficiency = preselection_efficiency; FillEfficiencyTree(vars); ///************************************* ///**** definition of electron ID **** ///**** https://twiki.cern.ch/twiki/bin/viewauth/CMS/SimpleCutBasedEleID ///**** https://twiki.cern.ch/twiki/bin/viewauth/CMS/SimpleCutBasedEleID2011 std::vector<double> BarrelSelections; std::vector<double> EndcapSelections; double eleCombinedIsoBarrel = gConfigParser -> readDoubleOption("Selection::eleCombinedIsoBarrel"); double elesigmaIetaIetaBarrel = gConfigParser -> readDoubleOption("Selection::elesigmaIetaIetaBarrel"); double eledPhiBarrel = gConfigParser -> readDoubleOption("Selection::eledPhiBarrel"); double eledEtaBarrel = gConfigParser -> readDoubleOption("Selection::eledEtaBarrel"); double eleCombinedIsoEndcap = gConfigParser -> readDoubleOption("Selection::eleCombinedIsoEndcap"); double elesigmaIetaIetaEndcap = gConfigParser -> readDoubleOption("Selection::elesigmaIetaIetaEndcap"); double eledPhiEndcap = gConfigParser -> readDoubleOption("Selection::eledPhiEndcap"); double eledEtaEndcap = gConfigParser -> readDoubleOption("Selection::eledEtaEndcap"); double elemishits = gConfigParser -> readDoubleOption("Selection::elemishits"); double eledist = gConfigParser -> readDoubleOption("Selection::eledist"); double eledcot = gConfigParser -> readDoubleOption("Selection::eledcot"); double eledzPV = gConfigParser -> readDoubleOption("Selection::eledzPV"); double eledxyPV = gConfigParser -> readDoubleOption("Selection::eledxyPV"); BarrelSelections.push_back(eleCombinedIsoBarrel); BarrelSelections.push_back(elesigmaIetaIetaBarrel); BarrelSelections.push_back(eledPhiBarrel); BarrelSelections.push_back(eledEtaBarrel); BarrelSelections.push_back(elemishits); BarrelSelections.push_back(eledist); BarrelSelections.push_back(eledcot); BarrelSelections.push_back(eledzPV); BarrelSelections.push_back(eledxyPV); EndcapSelections.push_back(eleCombinedIsoEndcap); EndcapSelections.push_back(elesigmaIetaIetaEndcap); EndcapSelections.push_back(eledPhiEndcap); EndcapSelections.push_back(eledEtaEndcap); EndcapSelections.push_back(elemishits); EndcapSelections.push_back(eledist); EndcapSelections.push_back(eledcot); EndcapSelections.push_back(eledzPV); EndcapSelections.push_back(eledxyPV); ///**** https://twiki.cern.ch/twiki/bin/viewauth/CMS/SimpleCutBasedEleID --> 2010 Data ///**** 95% **** /* BarrelSelections.push_back(0.15); ///==== iso Tk BarrelSelections.push_back(2.00); ///==== iso em BarrelSelections.push_back(0.12); ///==== iso had BarrelSelections.push_back(0.15); ///==== iso combined BarrelSelections.push_back(0.015); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.8); ///==== dPhi BarrelSelections.push_back(0.007); ///==== dEta EndCapSelections.push_back(0.08); ///==== iso Tk EndCapSelections.push_back(0.06); ///==== iso em EndCapSelections.push_back(0.05); ///==== iso had EndCapSelections.push_back(0.10); ///==== iso combined EndCapSelections.push_back(0.07); ///==== hOe EndCapSelections.push_back(0.03); ///==== sigmaIetaIeta EndCapSelections.push_back(0.7); ///==== dPhi EndCapSelections.push_back(0.01); ///==== dEta */ ///**** 90% **** /* BarrelSelections.push_back(0.12); ///==== iso Tk BarrelSelections.push_back(0.09); ///==== iso em BarrelSelections.push_back(0.10); ///==== iso had BarrelSelections.push_back(0.10); ///==== iso combined BarrelSelections.push_back(0.12); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.8); ///==== dPhi BarrelSelections.push_back(0.007); ///==== dEta EndCapSelections.push_back(0.05); ///==== iso Tk EndCapSelections.push_back(0.06); ///==== iso em EndCapSelections.push_back(0.03); ///==== iso had EndCapSelections.push_back(0.07); ///==== iso combined EndCapSelections.push_back(0.05); ///==== hOe EndCapSelections.push_back(0.03); ///==== sigmaIetaIeta EndCapSelections.push_back(0.7); ///==== dPhi EndCapSelections.push_back(0.007); ///==== dEta */ ///**** 80% **** /* BarrelSelections.push_back(0.09); ///==== iso Tk BarrelSelections.push_back(0.07); ///==== iso em BarrelSelections.push_back(0.10); ///==== iso had BarrelSelections.push_back(0.07); ///==== iso combined BarrelSelections.push_back(0.040); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.06); ///==== dPhi BarrelSelections.push_back(0.004); ///==== dEta EndCapSelections.push_back(0.04); ///==== iso Tk EndCapSelections.push_back(0.05); ///==== iso em EndCapSelections.push_back(0.025); ///==== iso had EndCapSelections.push_back(0.06); ///==== iso combined EndCapSelections.push_back(0.025); ///==== hOe EndCapSelections.push_back(0.03); ///==== sigmaIetaIeta EndCapSelections.push_back(0.03); ///==== dPhi EndCapSelections.push_back(0.007); ///==== dEta */ ///**** 70% **** /* BarrelSelections.push_back(0.05); ///==== iso Tk BarrelSelections.push_back(0.06); ///==== iso em BarrelSelections.push_back(0.03); ///==== iso had BarrelSelections.push_back(0.04); ///==== iso combined BarrelSelections.push_back(0.025); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.004); ///==== dPhi BarrelSelections.push_back(0.004); ///==== dEta EndCapSelections.push_back(0.025); ///==== iso Tk EndCapSelections.push_back(0.025); ///==== iso em EndCapSelections.push_back(0.02); ///==== iso had EndCapSelections.push_back(0.03); ///==== iso combined EndCapSelections.push_back(0.025); ///==== hOe EndCapSelections.push_back(0.03); ///==== sigmaIetaIeta EndCapSelections.push_back(0.02); ///==== dPhi EndCapSelections.push_back(0.005); ///==== dEta */ ///**** https://twiki.cern.ch/twiki/bin/viewauth/CMS/SimpleCutBasedEleID2011 --> 2011 Data ///**** 95% **** /* BarrelSelections.push_back(10000.); ///==== iso Tk BarrelSelections.push_back(10000.); ///==== iso em BarrelSelections.push_back(10000.); ///==== iso had BarrelSelections.push_back(0.150); ///==== iso combined BarrelSelections.push_back(10000.); ///==== hOe BarrelSelections.push_back(0.012); ///==== sigmaIetaIeta BarrelSelections.push_back(0.800); ///==== dPhi BarrelSelections.push_back(0.007); ///==== dEta EndCapSelections.push_back(10000.); ///==== iso Tk EndCapSelections.push_back(10000.); ///==== iso em EndCapSelections.push_back(10000.); ///==== iso had EndCapSelections.push_back(0.100); ///==== iso combined EndCapSelections.push_back(10000.); ///==== hOe EndCapSelections.push_back(0.031); ///==== sigmaIetaIeta EndCapSelections.push_back(0.7); ///==== dPhi EndCapSelections.push_back(0.011); ///==== dEta */ ///**** 90% **** /* BarrelSelections.push_back(10000.); ///==== iso Tk BarrelSelections.push_back(10000.); ///==== iso em BarrelSelections.push_back(10000.); ///==== iso had BarrelSelections.push_back(0.085); ///==== iso combined BarrelSelections.push_back(10000.); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.071); ///==== dPhi BarrelSelections.push_back(0.007); ///==== dEta EndCapSelections.push_back(10000.); ///==== iso Tk EndCapSelections.push_back(10000.); ///==== iso em EndCapSelections.push_back(10000.); ///==== iso had EndCapSelections.push_back(0.051); ///==== iso combined EndCapSelections.push_back(10000.); ///==== hOe EndCapSelections.push_back(0.031); ///==== sigmaIetaIeta EndCapSelections.push_back(0.047); ///==== dPhi EndCapSelections.push_back(0.011); ///==== dEta */ ///**** 85% **** /* BarrelSelections.push_back(10000.); ///==== iso Tk BarrelSelections.push_back(10000.); ///==== iso em BarrelSelections.push_back(10000.); ///==== iso had BarrelSelections.push_back(0.053); ///==== iso combined BarrelSelections.push_back(10000.); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.039); ///==== dPhi BarrelSelections.push_back(0.005); ///==== dEta EndCapSelections.push_back(10000.); ///==== iso Tk EndCapSelections.push_back(10000.); ///==== iso em EndCapSelections.push_back(10000.); ///==== iso had EndCapSelections.push_back(0.042); ///==== iso combined EndCapSelections.push_back(10000.); ///==== hOe EndCapSelections.push_back(0.031); ///==== sigmaIetaIeta EndCapSelections.push_back(0.028); ///==== dPhi EndCapSelections.push_back(0.007); ///==== dEta */ ///**** 80% **** /* BarrelSelections.push_back(10000.); ///==== iso Tk BarrelSelections.push_back(10000.); ///==== iso em BarrelSelections.push_back(10000.); ///==== iso had BarrelSelections.push_back(0.040); ///==== iso combined BarrelSelections.push_back(10000.); ///==== hOe BarrelSelections.push_back(0.01); ///==== sigmaIetaIeta BarrelSelections.push_back(0.027); ///==== dPhi BarrelSelections.push_back(0.005); ///==== dEta EndCapSelections.push_back(10000.); ///==== iso Tk EndCapSelections.push_back(10000.); ///==== iso em EndCapSelections.push_back(10000.); ///==== iso had EndCapSelections.push_back(0.033); ///==== iso combined EndCapSelections.push_back(10000.); ///==== hOe EndCapSelections.push_back(0.031); ///==== sigmaIetaIeta EndCapSelections.push_back(0.021); ///==== dPhi EndCapSelections.push_back(0.006); ///==== dEta */ ///*********************************** ///**** definition of muon ID **** std::vector<double> Selections; double muCombinedIso = gConfigParser -> readDoubleOption("Selection::muCombinedIso"); double muChi2Ndof = gConfigParser -> readDoubleOption("Selection::muChi2Ndof"); double muValidTrackerHits = gConfigParser -> readDoubleOption("Selection::muValidTrackerHits"); double muValidMuonHits = gConfigParser -> readDoubleOption("Selection::muValidMuonHits"); double mutracker = gConfigParser -> readDoubleOption("Selection::mutracker"); double mustandalone = gConfigParser -> readDoubleOption("Selection::mustandalone"); double muglobal = gConfigParser -> readDoubleOption("Selection::muglobal"); double mudzPV = gConfigParser -> readDoubleOption("Selection::mudzPV"); double mudxyPV = gConfigParser -> readDoubleOption("Selection::mudxyPV"); Selections.push_back(muCombinedIso); Selections.push_back(muChi2Ndof); Selections.push_back(muValidTrackerHits); Selections.push_back(muValidMuonHits); Selections.push_back(mutracker); Selections.push_back(mustandalone); Selections.push_back(muglobal); Selections.push_back(mudzPV); Selections.push_back(mudxyPV); /* Selections.push_back(0.15); ///==== iso Combined Selections.push_back(10); ///==== Chi2/ndof Selections.push_back(10); ///==== n ValidTrackerHits Selections.push_back(0); ///==== n ValidMuonHits Selections.push_back(1); ///==== tracker Selections.push_back(1); ///==== standalone Selections.push_back(1); ///==== global //Selections.push_back(1); ///==== goodMuon */ double start, end; std::cout << ">>>>> analysis::entryMIN " << entryMIN << " ==> entryMAX " << entryMAX << ":" << reader.GetEntries() << std::endl; int step = 0; start = clock(); for(int iEvent = entryMIN ; iEvent < entryMAX ; ++iEvent) { reader.GetEntry(iEvent); if((iEvent%entryMOD) == 0) std::cout << ">>>>> analysis::GetEntry " << iEvent << " : " << entryMAX - entryMIN << std::endl; ///==== define variables ==== std::vector<ROOT::Math::XYZTVector>* jets = reader.Get4V("jets"); // std::vector<ROOT::Math::XYZTVector>* muons = reader.Get4V("muons"); // std::vector<ROOT::Math::XYZTVector>* electrons = reader.Get4V("electrons"); ///********************************************************************************************* ///********************************************************************************************* ///============================= ///==== fill MC information ==== SetMCVariables(vars, reader); ///============================= ///==== fill Primary Vertex ==== SetPVVariables(vars, reader); ///================================ ///==== fill Event information ==== SetEventVariables(vars, reader); ///*************************************************** ///**** STEP -1 - Check no copies in DATA **** ///*************************************************** if (debug) std::cout << " STEP -1 " << std::endl; if( dataFlag == 1 ) { std::pair<int,int> eventLSandID(reader.GetInt("lumiId")->at(0), reader.GetInt("eventId")->at(0)); std::pair<int,std::pair<int,int> > eventRUNandLSandID(reader.GetInt("runId")->at(0), eventLSandID); if( eventsMap[eventRUNandLSandID] == 1 ) continue; else eventsMap[eventRUNandLSandID] = 1; } ///************************************************* ///**** Check comparison with JSON file *** ///************************************************* if( dataFlag == 1 ) { int runId = reader.GetInt("runId")->at(0); int lumiId = reader.GetInt("lumiId")->at(0); if(AcceptEventByRunAndLumiSection(runId, lumiId, jsonMap) == false) continue; } ///**************************** ///**** STEP 0 - Ntuplizer **** ///************* no additional selections applied step = 0; if (step > nStepToDo) { FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 0 <<<" << std::endl; ///********************************************* ///**** STEP 1 - Jet cleaning + min pT **** ///************* it's performed another time here to make sure that the cleaning worked well ///************* Jet - electrons (pT > 5) ///************* Jet - muons (pT > 5) ///************ In addition only jets with pT > 15 are considered from now on! ///************ No selections are applied here step = 1; if (step > nStepToDo) { // FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 1 <<<" << std::endl; std::vector<ROOT::Math::XYZTVector> leptons_jetCleaning; // build the collection of electros for jet cleaning ///==== CLEANING WITH ELECTRONS ==== for(unsigned int iEle = 0; iEle < (reader.Get4V("electrons")->size()); ++iEle) { if( reader.Get4V("electrons")->at(iEle).pt() < 5. ) continue; // bool flag = IsEleIsolatedID_VBF(reader,BarrelSelections,EndcapSelections,iEle); bool flag = IsEleIsolatedIDPUCorrected_VBF(reader,BarrelSelections,EndcapSelections,iEle); if (!flag) continue; leptons_jetCleaning.push_back( reader.Get4V("electrons")->at(iEle) ); } ///==== CLEANING WITH MUONS ==== for (int iMu = 0; iMu < reader.Get4V("muons")->size(); iMu++){ if (reader.Get4V("muons")->at(iMu).pt() < 5.0) continue; if (fabs(reader.Get4V("muons")->at(iMu).Eta()) > 2.5) continue; // bool flag = IsMuIsolatedID_VBF(reader,Selections,iMu); bool flag = IsMuIsolatedIDPUCorrected_VBF(reader,Selections,iMu); if (!flag) continue; leptons_jetCleaning.push_back( reader.Get4V("muons")->at(iMu) ); } ///==== now clean jet collection ==== int nJets = reader.Get4V("jets")->size(); std::vector<int> whitelistJet; ///~~~~ all jets, 0 if rejected, 1 if accepted std::vector<int> blacklistJet; ///~~~~ list of numbers of jets that are "rejected" std::vector<int> blacklistJet_forCJV; std::vector<int> blacklistJet_forBtag; for (int iJet = 0; iJet < nJets; iJet++){ bool skipJet = false; if (reader.Get4V("jets")->at(iJet).Et() < 15.0) skipJet = true; for(unsigned int iLep = 0; iLep < leptons_jetCleaning.size(); ++iLep) { ROOT::Math::XYZTVector lep = leptons_jetCleaning.at(iLep); if (ROOT::Math::VectorUtil::DeltaR(reader.Get4V("jets")->at(iJet),lep) < 0.3 ) skipJet = true; } if (skipJet) { whitelistJet.push_back(0); ///---- reject blacklistJet.push_back(iJet); ///---- reject ///== black list is in a different format blacklistJet_forCJV.push_back(iJet); ///---- reject ///== black list is in a different format blacklistJet_forBtag.push_back(iJet); ///---- reject ///== black list is in a different format } else { whitelistJet.push_back(1); ///---- select } } ///************************************** ///**** STEP 2 - Super-Preselections **** ///************* tighter preselections to start the analysis from the same point ///==== construct considered objets /// Objects considered and selections /// Muon /// Pt>10GeV, eta<2.5 /// MuonId & Iso /// /// Electron /// Pt>10GeV & |eta|<2.5 /// eleId & Iso /// /// At least two leptons /// Jet /// Antikt5, L2L3 correction jets /// At least two calo jets or two pf jets with pt>15 GeV //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ step = 2; if (step > nStepToDo) { // FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 2 <<<" << std::endl; /// Electron /// Pt>10GeV & |eta|<2.5 /// IsoTr / pTele <0.5 /// eleId & Iso std::vector<int> whitelistEle; std::vector<int> blacklistEle; int nEles = reader.Get4V("electrons")->size(); for (int iEle = 0; iEle < nEles; iEle++){ bool skipEle = false; if (reader.Get4V("electrons")->at(iEle).pt() < 10.0) skipEle = true; if (fabs(reader.Get4V("electrons")->at(iEle).Eta()) > 2.5) skipEle = true; // bool flag = IsEleIsolatedID_VBF(reader,BarrelSelections,EndcapSelections,iEle); bool flag = IsEleIsolatedIDPUCorrected_VBF(reader,BarrelSelections,EndcapSelections,iEle); if (!flag) skipEle = true; if (skipEle) { whitelistEle.push_back(0); ///---- reject blacklistEle.push_back(iEle); ///---- reject ///== black list is in a different format } else { whitelistEle.push_back(1); ///---- select } } /// Muon /// Pt>10GeV, eta<2.5 /// MuonId & Iso std::vector<int> whitelistMu; std::vector<int> blacklistMu; int nMus = reader.Get4V("muons")->size(); for (int iMu = 0; iMu < nMus; iMu++){ bool skipMu = false; if (reader.Get4V("muons")->at(iMu).pt() < 10.0) skipMu = true; if (fabs(reader.Get4V("muons")->at(iMu).Eta()) > 2.5) skipMu = true; // bool flag = IsMuIsolatedID_VBF(reader,Selections,iMu); bool flag = IsMuIsolatedIDPUCorrected_VBF(reader,Selections,iMu); if (!flag) skipMu = true; if (skipMu) { whitelistMu.push_back(0); ///---- reject blacklistMu.push_back(iMu); ///---- reject ///== black list is in a different format } else { whitelistMu.push_back(1); ///---- select } } /// At least 2 leptons int numMus_Accepted = GetNumList(whitelistMu); int numEles_Accepted = GetNumList(whitelistEle); int numLeptons_Accepted = numMus_Accepted + numEles_Accepted; if (numLeptons_Accepted < 2) continue; /// Jet /// At least two calo jets or two pf jets with pt>20 GeV int numJets_Accepted = GetNumList(whitelistJet); if (numJets_Accepted < 2) continue; ///==== at least 2 jets "isolated" ///************************* ///**** STEP 3 - Jet ID **** ///************* Identification of two tag jets step = 3; if (step > nStepToDo) { // FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 3 <<<" << std::endl; std::vector<int> itSelJet; double maxPt_jets_selected = SelectJets(itSelJet,*jets,"maxSumPt",-1.,&blacklistJet); int q1 = itSelJet.at(0); int q2 = itSelJet.at(1); ///---- check Pt order ---- if (jets->at(q1).Pt() < jets->at(q2).Pt()) { int tempq = q1; q1 = q2; q2 = tempq; } if (debug) std::cerr << " q1 = " << q1 << " : q2 = " << q2 << std::endl; ///---- update white/black list jets ---- for (int iJet = 0; iJet < nJets; iJet++){ if (q1 == iJet || q2 == iJet) { whitelistJet.at(iJet) = 1; blacklistJet.push_back(iJet); ///===> blacklistJet used for CJV => no 2 tag jets to be considered! blacklistJet_forCJV.push_back(iJet); ///===> blacklistJet used for CJV => no 2 tag jets to be considered! } else { whitelistJet.at(iJet) = 0; } } SetQJetVariables(vars, reader, q1, q2, blacklistJet_forCJV, blacklistJet_forBtag, blacklistJet_forBtag); ///******************************** ///**** STEP 4 - Lepton ID **** ///************* Identification of the two leptons step = 4; if (step > nStepToDo) { FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 4 <<<" << std::endl; std::vector<ROOT::Math::XYZTVector> leptons; std::vector<int> leptonFlavours; std::vector<int> leptonILep; for(unsigned int iEle = 0; iEle < nEles; iEle++){ if (whitelistEle.at(iEle) == 1){ leptons.push_back( reader.Get4V("electrons")->at(iEle) ); leptonFlavours.push_back(11); leptonILep.push_back(iEle); } } for(unsigned int iMu = 0; iMu < nMus; iMu++){ if (whitelistMu.at(iMu) == 1){ leptons.push_back( reader.Get4V("muons")->at(iMu) ); leptonFlavours.push_back(13); leptonILep.push_back(iMu); } } std::vector<int> itSelLep; double maxPt_lept_selected = SelectJets(itSelLep,leptons,"maxSumPt",-1.,0); int l1 = itSelLep.at(0); int l2 = itSelLep.at(1); ///---- check Pt order ---- if (leptons.at(l1).Pt() < leptons.at(l2).Pt()) { int templ = l1; l1 = l2; l2 = templ; } if (debug) std::cerr << " l1 = " << l1 << " : l2 = " << l2 << std::endl; SetLeptonsVariables(vars, reader, leptonILep.at(l1), leptonILep.at(l2),leptonFlavours.at(l1), leptonFlavours.at(l2)); if (debug) std::cerr << ">> Lepton variables set" << std::endl; SetMetVariables(vars, reader, "PFMet", leptonILep.at(l1), leptonILep.at(l2),leptonFlavours.at(l1), leptonFlavours.at(l2)); if (debug) std::cerr << ">> MET variables set" << std::endl; //---- lepton veto std::vector<int> blacklistLepton; blacklistLepton.push_back(l1); blacklistLepton.push_back(l2); vars.Nleptons_pT5 = getNumberPTThreshold(leptons, 5, &blacklistLepton); vars.Nleptons_pT10 = getNumberPTThreshold(leptons, 10, &blacklistLepton); vars.Nleptons_pT15 = getNumberPTThreshold(leptons, 15, &blacklistLepton); vars.Nleptons_pT20 = getNumberPTThreshold(leptons, 20, &blacklistLepton); vars.Nleptons_pT25 = getNumberPTThreshold(leptons, 25, &blacklistLepton); vars.Nleptons_pT30 = getNumberPTThreshold(leptons, 30, &blacklistLepton); if (debug) std::cerr << ">> Lepton multiplicity set" << std::endl; ///********************************* ///**** STEP 5 - Jet Selections **** ///************* Loose selections of tag jets step = 5; if (step > nStepToDo) { FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 5 <<<" << std::endl; ///---- hardcoded fixed preselections ---- VBF (begin) ---- if (vars.q1_pT < 20.) continue; if (vars.q2_pT < 15.) continue; if (vars.M_qq < 0.) continue; if (vars.DEta_qq < 0.) continue; ///---- hardcoded fixed preselections ---- VBF (end) ---- ///==== save trigger variables ==== SetTriggerVariables(vars, reader); ///************************************ ///**** STEP 6 - Final Production ***** ///************************************ ///**** No more selections applied **** step = 6; if (step > nStepToDo) { FillTree(vars); continue; } if (debug) std::cout << ">>> STEP 6 <<<" << std::endl; ///==== if not already filled ... ==== FillTree(vars); ///================================================= } end = clock(); std::cout <<"Time = " << ((double) (end - start)) << " (a.u.)" << std::endl; SaveTree(vars); std::cerr << " === end === " << std::endl; }