void plotweight(int isub){ TFile *f = TFile::Open("/phenix/u/xuq/xuq/taxi/Run15pAu200FVTXClusAna503/8845/data/435527_0.root"); int ivz = 0; TH1F* h = (TH1F*)f->Get(Form("phiweight_0_0_0_%d_0_%d",ivz,isub)); TH1F* hc = (TH1F*)h->Clone("hc"); h->Rebin(4); hc->Rebin(4); for(int ibin=0;ibin<=h->GetNbinsX();ibin++){ if(h->GetBinContent(ibin)!=0) hc->SetBinContent(ibin,h->Integral()/h->GetNbinsX()/h->GetBinContent(ibin)); else hc->SetBinContent(ibin,1.); } TCanvas *c1 = new TCanvas("c1"); hc->Draw(); TCanvas *c2 = new TCanvas("c2"); h->Draw(); }
mipana() { ScanConfigFile(); // int nBins = (int)(((int)(MAX_BIN - MIN_BIN +1))/((int)BIN_SIZE)); // cout << "nBins = " << nBins << endl; char inFileName[256]; char outFileName[256]; char tmpHistoName[256]; // TH2F *entries; for(int node = 0; node < nNodes; node ++) { TH1F *tmpHist; sprintf(inFileName,"%s_ClusterEnergies.root", nodes[node]); sprintf(outFileName, "%s_FilteredClusterEnergies.root", nodes[node]); TFile *infile = new TFile(inFileName, "read"); TFile *outFile = new TFile(outFileName, "recreate"); for(int z =Z_MIN; z < Z_MAX; z ++ ) { for(int x = X_MIN; x < X_MAX; x ++) { sprintf(tmpHistoName, "ClusterEnergies3x3_2_%d_%d_1", z, x); tmpHist = (TH1F*)infile->Get(tmpHistoName); if(tmpHist != 0) { cout << "rebinning histogram " << tmpHistoName <<endl; outFile->cd(); tmpHist->Rebin(4); tmpHist->Write(); infile->cd(); } else { // cout << "ERROR: histogram " << tmpHistoName << " doesnt exists" <<endl; } //do something } } infile->Close(); outFile->Close(); } }
TH1* his( TH1* input, Int_t nbins, Double_t xlow, Double_t xhigh ) { if ( !input ) { return 0; } TString name( TString(input->GetName()) + "Clone" ); TH1F* output = new TH1F( name, "", input->GetNbinsX(), xlow, xhigh ); for ( Int_t bin = 1; bin < input->GetNbinsX()+1; ++bin ) { Double_t centre = input->GetBinLowEdge(bin) + input->GetBinWidth(bin)/2.; if ( centre > xlow && centre < xhigh && input->GetBinContent(bin) > 0. ) { output->Fill( centre, input->GetBinContent(bin) ); } } output->Sumw2(); output->Rebin(Int_t(input->GetNbinsX()/nbins)); return output; }
void BackgroundFit() { TFile* inputFile = new TFile("0_MuScleFit.root", "READ"); TH1F* histo = (TH1F*)inputFile->FindObjectAny("hRecBestRes_Mass"); histo->Rebin(30); histo->Scale(1/histo->GetEntries()); // TF1 * functionToFit = lorentzianFit(); // TF1 * functionToFit = crystalBallFit(); // TF1 * functionToFit = powerLawFit(); // TF1 * functionToFit = lorentzianAndPowerLaw(); // TF1 * functionToFit = exponentialFit(); TF1 * functionToFit = lorenzianAndExponentialFit(); histo->Fit(functionToFit, "M", "", 42, 160); }
TH1F* readHist(TString nameHist,TString nameFile, TString nameDir, int rebin) { TFile* file = new TFile(nameFile); file->ls(); TDirectory *dir=(TDirectory*)file->Get(nameDir); TH1F* hist = (TH1F*)dir->Get(nameHist); // if (hist==0) return; hist->GetSumw2(); // hist->SetLineWidth(2); if(rebin>0) hist->Rebin(rebin); hist->GetXaxis()->SetTitleSize(.055); hist->GetYaxis()->SetTitleSize(.055); hist->GetXaxis()->SetLabelSize(.05); hist->GetYaxis()->SetLabelSize(.05); hist->SetStats(kFALSE); return hist; }
void rebin() { //create a fix bin histogram TH1F *h = new TH1F("h","test rebin",100,-3,3); Int_t nentries = 1000; h->FillRandom("gaus",nentries); Double_t xbins[1001]; Int_t k=0; TAxis *axis = h->GetXaxis(); for (Int_t i=1;i<=100;i++) { Int_t y = (Int_t)h->GetBinContent(i); if (y <=0) continue; Double_t dx = axis->GetBinWidth(i)/y; Double_t xmin = axis->GetBinLowEdge(i); for (Int_t j=0;j<y;j++) { xbins[k] = xmin +j*dx; k++; } } xbins[k] = axis->GetXmax(); //create a variable bin-width histogram out of fix bin histogram //new rebinned histogram should have about 10 entries per bin TH1F *hnew = new TH1F("hnew","rebinned",k,xbins); hnew->FillRandom("gaus",10*nentries); //rebin hnew keeping only 50% of the bins Double_t xbins2[501]; Int_t kk=0; for (Int_t j=0;j<k;j+=2) { xbins2[kk] = xbins[j]; kk++; } xbins2[kk] = xbins[k]; TH1F *hnew2 = (TH1F*)hnew->Rebin(kk,"hnew2",xbins2); //draw the 3 histograms TCanvas *c1 = new TCanvas("c1","c1",800,1000); c1->Divide(1,3); c1->cd(1); h->Draw(); c1->cd(2); hnew->Draw(); c1->cd(3); hnew2->Draw(); }
void ProbsFitter() { TFile * inputFile = new TFile("Sherpa_nocuts.root", "READ"); TH1F * histo = (TH1F*)inputFile->FindObjectAny("HistAllZMass"); histo->Scale(1/histo->GetEntries()); histo->Rebin(6); TCanvas * canvas = new TCanvas("canvas", "canvas", 1000, 800); canvas->Divide(2,3); // gStyle->SetOptFit(1); TF1 * residuals1 = iterateFitter(histo, 0, 0, canvas); // TF1 * residuals2 = iterateFitter(histo, 1, residuals1, canvas); // iterateFitter(histo, 2, residuals2, canvas); // canvas->cd(3); // TH1F * hclone = (TH1F*)histo->Clone(); // TF1 * combinedFunctionToFit = combinedFit(residualFitFunction->GetParameters()); // hclone->Fit(combinedFunctionToFit, "MN", "", 60, 120); // hclone->Draw(); // combinedFunctionToFit->Draw("same"); // combinedFunctionToFit->SetLineColor(kRed); }
void BINcomb(){ TFile *fqcd = new TFile("QCD.root"); TFile *fsig = new TFile("SIG.root"); TFile *fttb = new TFile("TTB.root"); double xcqcd = 25.42*1000; double xcttb = 831.76*1000; double xcsig = 0.0624391*1000; double lumi = 5.0 ; double nt_qcd = xcqcd*lumi; double nt_sig = xcsig*lumi; double nt_ttb = xcttb*lumi; fqcd->cd(); demo->cd(); double scf_qcd = nt_qcd/(1.0*Ev0->GetEntries()); TH1F *ak8ptq = ak8pt->Clone(); TH1F *t31q = ak8t31->Clone(); TH1F *ak8_phosubfq = ak8_phosubFrac->Clone(); TH1F *pm0q = ak8_prunnedM0->Clone(); TH1F *pm1q = ak8_prunnedM1->Clone(); TH1F *pm2q = ak8_prunnedM2->Clone(); TH1F *pm3q = ak8_prunnedM3->Clone(); TH1F *pm4q = ak8_prunnedM4->Clone(); TH1F *pm5q = ak8_prunnedM5->Clone(); TH1F *njt3q = NJT3->Clone(); TH1F *njl3q = NJL3->Clone(); TH1F *njt4q = NJT4->Clone(); TH1F *njl4q = NJL4->Clone(); TH1F *htaq = HTa->Clone(); TH1F *ht3q = HT3->Clone(); TH1F *ht4q = HT4->Clone(); TH1F *ht4l1q = HT4L1->Clone(); TH1F *ht4l2q = HT4L2->Clone(); TH1F *ht4t1q = HT4T1->Clone(); TH1F *ht4t2q = HT4T2->Clone(); TH1F *ht3l1q = HT3L1->Clone(); TH1F *ht3l2q = HT3L2->Clone(); TH1F *ht3t1q = HT3T1->Clone(); TH1F *ht3t2q = HT3T2->Clone(); TH1F *Thotmassq = T2jet_4evmasspruned->Clone(); TH1F *Lhotmassq = L3jet_4evmasspruned->Clone(); fttb->cd(); demo->cd(); double scf_ttb = nt_ttb/(1.0*Ev0->GetEntries()); TH1F *Thotmasst = T2jet_4evmasspruned->Clone(); TH1F *Lhotmasst = L3jet_4evmasspruned->Clone(); TH1F *ak8ptt = ak8pt->Clone(); TH1F *t31t = ak8t31->Clone(); TH1F *ak8_phosubft = ak8_phosubFrac->Clone(); TH1F *pm0t = ak8_prunnedM0->Clone(); TH1F *pm1t = ak8_prunnedM1->Clone(); TH1F *pm2t = ak8_prunnedM2->Clone(); TH1F *pm3t = ak8_prunnedM3->Clone(); TH1F *pm4t = ak8_prunnedM4->Clone(); TH1F *pm5t = ak8_prunnedM5->Clone(); TH1F *njt3t = NJT3->Clone(); TH1F *njl3t = NJL3->Clone(); TH1F *njt4t = NJT4->Clone(); TH1F *njl4t = NJL4->Clone(); TH1F *htat = HTa->Clone(); TH1F *ht3t = HT3->Clone(); TH1F *ht4t = HT4->Clone(); TH1F *ht4l1t = HT4L1->Clone(); TH1F *ht4l2t = HT4L2->Clone(); TH1F *ht4t1t = HT4T1->Clone(); TH1F *ht4t2t = HT4T2->Clone(); TH1F *ht3l1t = HT3L1->Clone(); TH1F *ht3l2t = HT3L2->Clone(); TH1F *ht3t1t = HT3T1->Clone(); TH1F *ht3t2t = HT3T2->Clone(); fsig->cd(); demo->cd(); double scf_sig = nt_sig/(1.0*Ev0->GetEntries()); TH1F *Thotmasss = T2jet_4evmasspruned->Clone(); TH1F *Lhotmasss = L3jet_4evmasspruned->Clone(); TH1F *ak8pts = ak8pt->Clone(); TH1F *t31s = ak8t31->Clone(); TH1F *ak8_phosubfs = ak8_phosubFrac->Clone(); TH1F *pm0s = ak8_prunnedM0->Clone(); TH1F *pm1s = ak8_prunnedM1->Clone(); TH1F *pm2s = ak8_prunnedM2->Clone(); TH1F *pm3s = ak8_prunnedM3->Clone(); TH1F *pm4s = ak8_prunnedM4->Clone(); TH1F *pm5s = ak8_prunnedM5->Clone(); TH1F *njt3s = NJT3->Clone(); TH1F *njl3s = NJL3->Clone(); TH1F *njt4s = NJT4->Clone(); TH1F *njl4s = NJL4->Clone(); TH1F *htas = HTa->Clone(); TH1F *ht3s = HT3->Clone(); TH1F *ht4s = HT4->Clone(); TH1F *ht4l1s = HT4L1->Clone(); TH1F *ht4l2s = HT4L2->Clone(); TH1F *ht4t1s = HT4T1->Clone(); TH1F *ht4t2s = HT4T2->Clone(); TH1F *ht3l1s = HT3L1->Clone(); TH1F *ht3l2s = HT3L2->Clone(); TH1F *ht3t1s = HT3T1->Clone(); TH1F *ht3t2s = HT3T2->Clone(); //Scaling all the historgrams: ak8pts->Scale(scf_sig); t31s->Scale(scf_sig); ak8_phosubfs->Scale(scf_sig); pm0s->Scale(scf_sig); pm1s->Scale(scf_sig); pm2s->Scale(scf_sig); pm3s->Scale(scf_sig); pm4s->Scale(scf_sig); pm5s->Scale(scf_sig); njt3s->Scale(scf_sig); njl3s->Scale(scf_sig); njt4s->Scale(scf_sig); njl4s->Scale(scf_sig); htas->Scale(scf_sig); ht3s->Scale(scf_sig); ht4s->Scale(scf_sig); ht4l1s->Scale(scf_sig); ht4l2s->Scale(scf_sig); ht4t1s->Scale(scf_sig); ht4t2s->Scale(scf_sig); ht3l1s->Scale(scf_sig); ht3l2s->Scale(scf_sig); ht3t1s->Scale(scf_sig); ht3t2s->Scale(scf_sig); Thotmasss->Scale(scf_sig); Lhotmasss->Scale(scf_sig); Thotmasss->SetFillColor(kRed); Lhotmasss->SetFillColor(kRed); ak8pts->SetFillColor(kRed); t31s->SetFillColor(kRed); ak8_phosubfs->SetFillColor(kRed); pm0s->SetFillColor(kRed); pm1s->SetFillColor(kRed); pm2s->SetFillColor(kRed); pm3s->SetFillColor(kRed); pm4s->SetFillColor(kRed); pm5s->SetFillColor(kRed); njt3s->SetFillColor(kRed); njl3s->SetFillColor(kRed); njt4s->SetFillColor(kRed); njl4s->SetFillColor(kRed); htas->SetFillColor(kRed); ht3s->SetFillColor(kRed); ht4s->SetFillColor(kRed); ht4l1s->SetFillColor(kRed); ht4l2s->SetFillColor(kRed); ht4t1s->SetFillColor(kRed); ht4t2s->SetFillColor(kRed); ht3l1s->SetFillColor(kRed); ht3l2s->SetFillColor(kRed); ht3t1s->SetFillColor(kRed); ht3t2s->SetFillColor(kRed); Thotmasss->SetLineColor(kRed); Lhotmasss->SetLineColor(kRed); ak8pts->SetLineColor(kRed); t31s->SetLineColor(kRed); ak8_phosubfs->SetLineColor(kRed); pm0s->SetLineColor(kRed); pm1s->SetLineColor(kRed); pm2s->SetLineColor(kRed); pm3s->SetLineColor(kRed); pm4s->SetLineColor(kRed); pm5s->SetLineColor(kRed); njt3s->SetLineColor(kRed); njl3s->SetLineColor(kRed); njt4s->SetLineColor(kRed); njl4s->SetLineColor(kRed); htas->SetLineColor(kRed); ht3s->SetLineColor(kRed); ht4s->SetLineColor(kRed); ht4l1s->SetLineColor(kRed); ht4l2s->SetLineColor(kRed); ht4t1s->SetLineColor(kRed); ht4t2s->SetLineColor(kRed); ht3l1s->SetLineColor(kRed); ht3l2s->SetLineColor(kRed); ht3t1s->SetLineColor(kRed); ht3t2s->SetLineColor(kRed); ak8ptq->Scale(scf_qcd); t31q->Scale(scf_qcd); ak8_phosubfq->Scale(scf_qcd); pm0q->Scale(scf_qcd); pm1q->Scale(scf_qcd); pm2q->Scale(scf_qcd); pm3q->Scale(scf_qcd); pm4q->Scale(scf_qcd); pm5q->Scale(scf_qcd); njt3q->Scale(scf_qcd); njl3q->Scale(scf_qcd); njt4q->Scale(scf_qcd); njl4q->Scale(scf_qcd); htaq->Scale(scf_qcd); ht3q->Scale(scf_qcd); ht4q->Scale(scf_qcd); ht4l1q->Scale(scf_qcd); ht4l2q->Scale(scf_qcd); ht4t1q->Scale(scf_qcd); ht4t2q->Scale(scf_qcd); ht3l1q->Scale(scf_qcd); ht3l2q->Scale(scf_qcd); ht3t1q->Scale(scf_qcd); ht3t2q->Scale(scf_qcd); Thotmassq->Scale(scf_qcd); Lhotmassq->Scale(scf_qcd); Thotmassq->SetFillColor(kGray+3); Lhotmassq->SetFillColor(kGray+3); ak8ptq->SetFillColor(kGray+3); t31q->SetFillColor(kGray+3); ak8_phosubfq->SetFillColor(kGray+3); pm0q->SetFillColor(kGray+3); pm1q->SetFillColor(kGray+3); pm2q->SetFillColor(kGray+3); pm3q->SetFillColor(kGray+3); pm4q->SetFillColor(kGray+3); pm5q->SetFillColor(kGray+3); njt3q->SetFillColor(kGray+3); njl3q->SetFillColor(kGray+3); njt4q->SetFillColor(kGray+3); njl4q->SetFillColor(kGray+3); htaq->SetFillColor(kGray+3); ht3q->SetFillColor(kGray+3); ht4q->SetFillColor(kGray+3); ht4l1q->SetFillColor(kGray+3); ht4l2q->SetFillColor(kGray+3); ht4t1q->SetFillColor(kGray+3); ht4t2q->SetFillColor(kGray+3); ht3l1q->SetFillColor(kGray+3); ht3l2q->SetFillColor(kGray+3); ht3t1q->SetFillColor(kGray+3); ht3t2q->SetFillColor(kGray+3); Thotmassq->SetLineColor(kGray+3); Lhotmassq->SetLineColor(kGray+3); ak8ptq->SetLineColor(kGray+3); t31q->SetLineColor(kGray+3); ak8_phosubfq->SetLineColor(kGray+3); pm0q->SetLineColor(kGray+3); pm1q->SetLineColor(kGray+3); pm2q->SetLineColor(kGray+3); pm3q->SetLineColor(kGray+3); pm4q->SetLineColor(kGray+3); pm5q->SetLineColor(kGray+3); njt3q->SetLineColor(kGray+3); njl3q->SetLineColor(kGray+3); njt4q->SetLineColor(kGray+3); njl4q->SetLineColor(kGray+3); htaq->SetLineColor(kGray+3); ht3q->SetLineColor(kGray+3); ht4q->SetLineColor(kGray+3); ht4l1q->SetLineColor(kGray+3); ht4l2q->SetLineColor(kGray+3); ht4t1q->SetLineColor(kGray+3); ht4t2q->SetLineColor(kGray+3); ht3l1q->SetLineColor(kGray+3); ht3l2q->SetLineColor(kGray+3); ht3t1q->SetLineColor(kGray+3); ht3t2q->SetLineColor(kGray+3); ak8ptt->Scale(scf_ttb); t31t->Scale(scf_ttb); ak8_phosubft->Scale(scf_ttb); pm0t->Scale(scf_ttb); pm1t->Scale(scf_ttb); pm2t->Scale(scf_ttb); pm3t->Scale(scf_ttb); pm4t->Scale(scf_ttb); pm5t->Scale(scf_ttb); njt3t->Scale(scf_ttb); njl3t->Scale(scf_ttb); njt4t->Scale(scf_ttb); njl4t->Scale(scf_ttb); htat->Scale(scf_ttb); ht3t->Scale(scf_ttb); ht4t->Scale(scf_ttb); ht4l1t->Scale(scf_ttb); ht4l2t->Scale(scf_ttb); ht4t1t->Scale(scf_ttb); ht4t2t->Scale(scf_ttb); ht3l1t->Scale(scf_ttb); ht3l2t->Scale(scf_ttb); ht3t1t->Scale(scf_ttb); ht3t2t->Scale(scf_ttb); Thotmasst->Scale(scf_ttb); Lhotmasst->Scale(scf_ttb); Thotmasst->SetFillColor(kMagenta); Lhotmasst->SetFillColor(kMagenta); ak8ptt->SetFillColor(kMagenta); t31t->SetFillColor(kMagenta); ak8_phosubft->SetFillColor(kMagenta); pm0t->SetFillColor(kMagenta); pm1t->SetFillColor(kMagenta); pm2t->SetFillColor(kMagenta); pm3t->SetFillColor(kMagenta); pm4t->SetFillColor(kMagenta); pm5t->SetFillColor(kMagenta); njt3t->SetFillColor(kMagenta); njl3t->SetFillColor(kMagenta); njt4t->SetFillColor(kMagenta); njl4t->SetFillColor(kMagenta); htat->SetFillColor(kMagenta); ht3t->SetFillColor(kMagenta); ht4t->SetFillColor(kMagenta); ht4l1t->SetFillColor(kMagenta); ht4l2t->SetFillColor(kMagenta); ht4t1t->SetFillColor(kMagenta); ht4t2t->SetFillColor(kMagenta); ht3l1t->SetFillColor(kMagenta); ht3l2t->SetFillColor(kMagenta); ht3t1t->SetFillColor(kMagenta); ht3t2t->SetFillColor(kMagenta); Thotmasst->SetLineColor(kMagenta); Lhotmasst->SetLineColor(kMagenta); ak8ptt->SetLineColor(kMagenta); t31t->SetLineColor(kMagenta); ak8_phosubft->SetLineColor(kMagenta); pm0t->SetLineColor(kMagenta); pm1t->SetLineColor(kMagenta); pm2t->SetLineColor(kMagenta); pm3t->SetLineColor(kMagenta); pm4t->SetLineColor(kMagenta); pm5t->SetLineColor(kMagenta); njt3t->SetLineColor(kMagenta); njl3t->SetLineColor(kMagenta); njt4t->SetLineColor(kMagenta); njl4t->SetLineColor(kMagenta); htat->SetLineColor(kMagenta); ht3t->SetLineColor(kMagenta); ht4t->SetLineColor(kMagenta); ht4l1t->SetLineColor(kMagenta); ht4l2t->SetLineColor(kMagenta); ht4t1t->SetLineColor(kMagenta); ht4t2t->SetLineColor(kMagenta); ht3l1t->SetLineColor(kMagenta); ht3l2t->SetLineColor(kMagenta); ht3t1t->SetLineColor(kMagenta); ht3t2t->SetLineColor(kMagenta); THStack *hpt = new THStack("hpt","JetsPt"); hpt->Add(ak8ptq); hpt->Add(ak8ptt); hpt->Add(ak8pts); THStack *ht31 = new THStack("ht31","JetsPt"); ht31->Add(t31q); ht31->Add(t31t); ht31->Add(t31s); THStack *hphos = new THStack("hphos","JetsPt"); hphos->Add(ak8_phosubfq); hphos->Add(ak8_phosubft); hphos->Add(ak8_phosubfs); THStack *hhaspho = new THStack("hhaspho","JetsPt"); //hhaspho->Add THStack *hm0 = new THStack("hm0","JetsPt"); hm0->Add(pm0q); hm0->Add(pm0t); hm0->Add(pm0s); THStack *hm1 = new THStack("hm1","JetsPt"); hm1->Add(pm1q); hm1->Add(pm1t); hm1->Add(pm1s); THStack *hm2 = new THStack("hm2","JetsPt"); hm2->Add(pm2q); hm2->Add(pm2t); hm2->Add(pm2s); THStack *hm3 = new THStack("hm3","JetsPt"); hm3->Add(pm3q); hm3->Add(pm3t); hm3->Add(pm3s); THStack *hm4 = new THStack("hm4","JetsPt"); hm4->Add(pm4q); hm4->Add(pm4t); hm4->Add(pm4s); THStack *hm5 = new THStack("hm5","JetsPt"); hm5->Add(pm5q); hm5->Add(pm5t); hm5->Add(pm5s); //************************ THStack *nj3t = new THStack("nj3t","3 j Evs tight Jets"); nj3t->Add(njt3q); nj3t->Add(njt3t); nj3t->Add(njt3s); THStack *nj3l = new THStack("nj3l","3 j Evs loose Jets"); nj3l->Add(njl3q); nj3l->Add(njl3t); nj3l->Add(njl3s); THStack *nj4t = new THStack("nj4t","4 j Evs tight Jets"); nj4t->Add(njt4q); nj4t->Add(njt4t); nj4t->Add(njt4s); THStack *nj4l = new THStack("nj4l","4 j Evs loose Jets"); nj4l->Add(njl4q); nj4l->Add(njl4t); nj4l->Add(njl4s); //Rebinning the mass plots Lhotmassq->Rebin(2); Lhotmasst->Rebin(2); Lhotmasss->Rebin(2); Thotmassq->Rebin(2); Thotmasst->Rebin(2); Thotmasss->Rebin(2); THStack *nj4l2m = new THStack("nj4l2m","4 j mass Evs loose Jets"); nj4l2m->Add(Lhotmassq); nj4l2m->Add(Lhotmasst); nj4l2m->Add(Lhotmasss); THStack *nj4T2m = new THStack("nj4T2m","4 j mass Evs Tight Jets"); nj4T2m->Add(Thotmassq); nj4T2m->Add(Thotmasst); nj4T2m->Add(Thotmasss); TCanvas *c1 = new TCanvas("c1","step1",1200,600); c1->Divide(2,1); c1->cd(1); hpt->Draw(); hpt->GetXaxis()->SetTitle("Jet Pt GeVc^{-1}"); c1->cd(2); hm1->Draw(); hm1->GetXaxis()->SetTitle("Jet Prunned Mass GeVc^{-2}"); c1->Update(); c1->SaveAs("ptcut.png"); TCanvas *c2 = new TCanvas("c2","step2",1200,600); c2->Divide(2,1); c2->cd(1); ht31->Draw(); ht31->GetXaxis()->SetTitle("#tau_3/#tau_1"); c2->cd(2); hm2->Draw(); hm2->GetXaxis()->SetTitle("Jet Prunned Mass GeVc^{-2}"); c2->Update(); c2->SaveAs("ht31.png"); /* TCanvas *c3 = new TCanvas("c3","step2",1200,600); c3->Divide(2,1); c3->cd(1); hhasphos->Draw(); hhasphos->GetXaxis()->SetTitle("Has Photon Pt > 20 GeVc^{-1}"); c3->cd(2); hm3->Draw(); hm3->GetXaxis()->SetTitle("Jet Prunned Mass GeVc^{-2}"); c3->SaveAs("hasphos.png"); */ TCanvas *c4 = new TCanvas("c4","step2",1200,600); c4->Divide(2,1); c4->cd(1); hphos->Draw(); hphos->GetXaxis()->SetTitle("Pt_{#gamma}/Pt_{subjet}"); c4->cd(2); hm4->Draw(); hm4->GetXaxis()->SetTitle("Jet Prunned Mass GeVc^{-2}"); c4->Update(); c4->SaveAs("phos.png"); TCanvas *c5 = new TCanvas("","",1200,800); c5->Divide(4,2); c5->cd(1); c5->cd(1); c5->cd(1); c5->cd(1); c5->cd(1); c5->cd(1); c5->SaveAs("HTplots.png"); TCanvas *c6 = new TCanvas("c6","",1000,1000); c6->Divide(2,2); c6->cd(1)->SetLogy(); nj3l->Draw(); nj3l->GetXaxis()->SetTitle("Njets Loose per event"); c6->cd(2)->SetLogy(); nj3t->Draw(); nj3t->GetXaxis()->SetTitle("Njets Tight per event"); c6->cd(3)->SetLogy(); nj4l->Draw(); nj4l->GetXaxis()->SetTitle("Njets Loose per event"); c6->cd(4)->SetLogy(); nj4t->Draw(); nj4t->GetXaxis()->SetTitle("Njets Tight per event"); c6->Update(); c6->SaveAs("NjTL.png"); TCanvas *c7 = new TCanvas("c7","",1000,500); c7->Divide(2,1); c7->cd(1); nj4l2m->Draw(); nj4l2m->GetXaxis()->SetTitle("Jet Prunned Mass GeVc^{-2}"); c7->cd(2); nj4T2m->Draw(); nj4T2m->GetXaxis()->SetTitle("Jet Prunned Mass GeVc^{-2}"); c7->SaveAs("PrnM_sel.png"); }
void plot_histograms() { gROOT->Reset(); gROOT->SetStyle("Plain"); gROOT->LoadMacro("./get_th1f.C"); TH1F* hecore; TH1F* hecores; TH1F* hecore_first; TH1F* hecore_second; TH1F* hecore_seconds; TH1F* hecore_secondt; TH1F* hecore_secondts; TFile* finput = new TFile("../../data/histograms/h.sii.ln2o.root"); //TFile* finput = new TFile("histograms/h.susie.k1.root"); //TFile* finput = new TFile("histograms/h.si.k1.root"); //TFile* finput = new TFile("histograms/h.siii.g2.root"); // TFile* finput = new TFile("histograms/h.siii.feb2010.root"); finput->cd(); hecore = (TH1F*) get_th1f("hecore")->Clone(); hecores = (TH1F*) get_th1f("hecores")->Clone(); hecore_first = (TH1F*) get_th1f("hecore_first")->Clone(); hecore_second = (TH1F*) get_th1f("hecore_second")->Clone(); hecore_seconds = (TH1F*) get_th1f("hecore_seconds")->Clone(); hecore_secondt = (TH1F*) get_th1f("hecore_secondt")->Clone(); hecore_secondts = (TH1F*) get_th1f("hecore_secondts")->Clone(); // hecore->Rebin(10); hecore->Rebin(10); hecores->Rebin(10); hecore_first->Rebin(100); hecore_second->Rebin(100); hecore_seconds->Rebin(100); hecore_secondt->Rebin(100); hecore_secondts->Rebin(100); TCanvas* c1 = new TCanvas("c1","c1",10,10,900,600); c1->cd(); gPad->SetLogy(); hecore->GetXaxis()->SetTitle("Ecore [keV]"); hecore->GetYaxis()->SetTitle("Entries/10keV"); hecore->Draw(); hecores->SetLineColor(kRed); //hecores->SetFillColor(kRed); hecores->Draw("same"); TLegend* lone = new TLegend(0.5,0.5,0.85,0.75); lone->SetFillStyle(0); lone->AddEntry(hecore,"all events", "l"); lone->AddEntry(hecores,"single-segment events", "l"); lone->Draw(); c1->Update(); c1->Print("../../data/plots/siio/ecore_ss.eps"); TCanvas* c2 = new TCanvas("c2","c2",10,10,900,600); c2->cd(); hecore_first->Draw(); c2->Update(); TCanvas* c3 = new TCanvas("c3","c3",10,10,900,600); c3->cd(); gPad->SetLogy(); hecore_second->SetTitle("second event"); hecore_second->GetXaxis()->SetTitle("Ecore [keV]"); hecore_second->GetYaxis()->SetTitle("Entries/100keV"); hecore_second->SetLineWidth(2); hecore_second->SetMinimum(0.1); hecore_second->Draw(); //hecore_seconds->SetLineColor(kRed); //hecore_seconds->SetFillColor(kRed); //hecore_seconds->Draw("same"); hecore_secondt->SetLineColor(kBlue); hecore_secondt->SetLineWidth(2); hecore_secondt->Draw("same"); hecore_secondts->SetLineColor(kRed); hecore_secondts->SetLineWidth(2); hecore_secondts->Draw("same"); TLegend* ltwo = new TLegend(0.4,0.5,0.85,0.75); ltwo->SetFillStyle(0); ltwo->AddEntry(hecore_second,"Bi214 consecutive events","l"); ltwo->AddEntry(hecore_secondt,"5x164 #mus time window","l"); ltwo->AddEntry(hecore_secondts,"5x164 #mus and single-segment","l"); ltwo->Draw(); c3->Update(); c3->Print("../../data/plots/siio/ecore_bi214.eps"); }
//================================================ void DeltaZVsPos(const Int_t save = 0) { THnSparseF *hn = (THnSparseF*)f->Get(Form("mhTrkDzDy_%s",trigName[kTrigType])); TList *list = new TList; // dz vs BL TH2F *hTrkDzVsBL = (TH2F*)hn->Projection(1,3); c = draw2D(hTrkDzVsBL,Form("%s: #Deltaz of matched track-hit pairs",trigName[kTrigType])); if(save) { c->SaveAs(Form("~/Work/STAR/analysis/Plots/%s/ana_Match/%sDeltaZ_vs_BL_%s.pdf",run_type,run_cfg_name.Data(),trigName[kTrigType])); c->SaveAs(Form("~/Work/STAR/analysis/Plots/%s/ana_Match/%sDeltaZ_vs_BL_%s.png",run_type,run_cfg_name.Data(),trigName[kTrigType])); } list->Clear(); TString legName[30]; TH1F *hTrkDzInBL[30]; Int_t counter = 0; for(Int_t i=0; i<30; i++) { hTrkDzInBL[i] = (TH1F*)hTrkDzVsBL->ProjectionY(Form("hDeltaZ_BL%d",i+1),i+1,i+1); if(hTrkDzInBL[i]->GetEntries()>0) { legName[counter] = Form("Module %d",i+1); hTrkDzInBL[i]->SetLineColor(color[counter]); list->Add(hTrkDzInBL[i]); counter ++; } } c = drawHistos(list,"TrkDzInBL",Form("%s: #Deltaz of matched track-hit pairs in backleg;#Deltaz (cm)",trigName[kTrigType]),kTRUE,-100,100,kTRUE,0,1.2*hTrkDzInBL[1]->GetMaximum(),kFALSE,kTRUE,legName,kTRUE,"",0.15,0.25,0.2,0.88,kFALSE,0.04,0.04,kFALSE,1,kTRUE,kFALSE); TLine *line = GetLine(0,0,0,1.1*hTrkDzInBL[1]->GetMaximum(),1); line->Draw(); if(save) { c->SaveAs(Form("~/Work/STAR/analysis/Plots/%s/ana_Match/%sDeltaZ_in_BL_%s.pdf",run_type,run_cfg_name.Data(),trigName[kTrigType])); c->SaveAs(Form("~/Work/STAR/analysis/Plots/%s/ana_Match/%sDeltaZ_in_BL_%s.png",run_type,run_cfg_name.Data(),trigName[kTrigType])); } // dz vs Mod TH2F *hTrkDzVsMod = (TH2F*)hn->Projection(1,4); c = draw2D(hTrkDzVsMod,Form("%s: #Deltaz of matched track-hit pairs",trigName[kTrigType])); if(save) { c->SaveAs(Form("~/Work/STAR/analysis/Plots/%s/ana_Match/%sDeltaZ_vs_Mod_%s.pdf",run_type,run_cfg_name.Data(),trigName[kTrigType])); c->SaveAs(Form("~/Work/STAR/analysis/Plots/%s/ana_Match/%sDeltaZ_vs_Mod_%s.png",run_type,run_cfg_name.Data(),trigName[kTrigType])); } TH1F *hMthMod = (TH1F*)hTrkDzVsMod->ProjectionX("hMthMod"); hMthMod->Sumw2(); hMthMod->Scale(1./hMthMod->Integral()); TH2F *hMtdHitMap = (TH2F*)f->Get(Form("mhMtdHitMap_%s",trigName[kTrigType])); TH1F *htmp = (TH1F*)hMtdHitMap->ProjectionY("hHitMod_finebin"); htmp->Rebin(12); TH1F *hMtdHitMod = new TH1F(Form("hMtdHitMod_%s",trigName[kTrigType]),"# of MTD hits per module;module",5,1,6); for(int i=0; i<hMtdHitMod->GetNbinsX(); i++) { hMtdHitMod->SetBinContent(i+1,htmp->GetBinContent(i+1)); hMtdHitMod->SetBinError(i+1,htmp->GetBinError(i+1)); } hMtdHitMod->Scale(1./hMtdHitMod->Integral()); list->Clear(); list->Add(hMthMod); list->Add(hMtdHitMod); TString legName3[2] = {"Matched good hits","All good hits"}; c = drawHistos(list,"MtdHitMod",Form("%s: MTD hits per module;module;probability",trigName[kTrigType]),kFALSE,0,5,kTRUE,0,0.5,kFALSE,kTRUE,legName3,kTRUE,"",0.15,0.25,0.6,0.88,kTRUE); if(save) { c->SaveAs(Form("~/Work/STAR/analysis/Plots/%s/ana_Match/%sCompMtdHitMod_%s.pdf",run_type,run_cfg_name.Data(),trigName[kTrigType])); c->SaveAs(Form("~/Work/STAR/analysis/Plots/%s/ana_Match/%sCompMtdHitMod_%s.png",run_type,run_cfg_name.Data(),trigName[kTrigType])); } list->Clear(); TString legName2[5]; TH1F *hTrkDzInMod[5]; for(Int_t i=0; i<5; i++) { hTrkDzInMod[i] = (TH1F*)hTrkDzVsMod->ProjectionY(Form("hDeltaZ_Mod%d",i+1),i+1,i+1); legName2[i] = Form("Module %d",i+1); list->Add(hTrkDzInMod[i]); } c = drawHistos(list,"TrkDzInMod",Form("%s: #Deltaz of matched track-hit pairs in module;#Deltaz (cm)",trigName[kTrigType]),kTRUE,-100,100,kTRUE,0,1.2*hTrkDzInMod[3]->GetMaximum(),kFALSE,kTRUE,legName2,kTRUE,"",0.15,0.25,0.6,0.88,kTRUE); TLine *line = GetLine(0,0,0,hTrkDzInMod[3]->GetMaximum()*1.05,1); line->Draw(); if(save) { c->SaveAs(Form("~/Work/STAR/analysis/Plots/%s/ana_Match/%sDeltaZ_in_Mod_%s.pdf",run_type,run_cfg_name.Data(),trigName[kTrigType])); c->SaveAs(Form("~/Work/STAR/analysis/Plots/%s/ana_Match/%sDeltaZ_in_Mod_%s.png",run_type,run_cfg_name.Data(),trigName[kTrigType])); } }
void plottingmacro() { setTDRStyle(); gROOT->ForceStyle(); initOptions(); std::vector<Sample> s = samples(); Sample data(1,"fake data","S1.root",0,true,1000); for(size_t i=0;i< s.size();i++) if(s[i].data) {data=s[i];break;} data.file()->ls(); for(size_t i=0;i< s.size();i++) s[i].dump(data.lumi()); std::vector<std::string> names; TList * subs = data.file()->GetListOfKeys(); for(size_t i=0;i< subs->GetSize();i++) { TList * objs = ((TDirectoryFile *) data.file()->Get(subs->At(i)->GetName()))->GetListOfKeys(); for(size_t j=0;j< objs->GetSize();j++) { names.push_back(subs->At(i)->GetName()+std::string("/") + objs->At(j)->GetName()); // std::cout << subs->At(i)->GetName() << "/" << objs->At(j)->GetName() << std::endl; //TODO: select plots via regexp } } for(size_t i = 0 ; i < names.size() ; i++) { std::map<std::string,TH1F *> grouped; TString n=names[i]; if(!n.Contains(TRegexp("V.*RegionH.*mu.*HiggsMass"))) continue; TCanvas *c = new TCanvas(); c->SetLogy(true); c->SetTitle(names[i].c_str()); TH1F *hd = ((TH1F*)data.file()->Get(names[i].c_str())); Options o=options[names[i]]; hd->Rebin(o.rebin); hd->SetMarkerStyle(21); hd->Draw("E1"); hd->SetYTitle(o.yaxis.c_str()); THStack * sta = new THStack("sta",hd->GetTitle()); TLegend * l = new TLegend(o.legendx1,o.legendy1,o.legendx2,o.legendy2); //0.7,0.1,0.9,0.6); l->AddEntry(hd, "Data","LP"); for(size_t j=0;j< s.size() ;j++) { if(!s[j].data) { TH1F * h = ((TH1F*)s[j].file()->Get(names[i].c_str())); h->Scale(s[j].scale(data.lumi())); h->SetLineColor(s[j].color); h->SetFillColor(s[j].color); h->Rebin(options[names[i]].rebin); if(grouped.find(s[j].name)==grouped.end()) { grouped[s[j].name]=(TH1F *)h->Clone(("_"+names[i]).c_str()); l->AddEntry(h,s[j].name.c_str(),"F"); } else { grouped[s[j].name]->Add(h); } sta->Add(h); // h->Draw("same"); } } sta->Draw("same"); hd->Draw("E1same"); hd->GetYaxis()->SetRangeUser(options[names[i]].min,options[names[i]].max); l->Draw(); std::cout << names[i] << " d: " << hd->Integral() << " "; THStack * sta2 = new THStack("sta2",hd->GetTitle()); float tot=0; float toterr2=0; for(std::map<std::string,TH1F *>::iterator it = grouped.begin(); it != grouped.end();it++) { std::cout << it->first << " " << it->second->Integral() << " | " ; if(it->second->GetEntries() > 0) { float er=1.*sqrt(it->second->GetEntries())/it->second->GetEntries()*it->second->Integral(); toterr2+=er*er; } tot+=it->second->Integral(); sta2->Add(it->second); } std::cout << " Tot: " << tot << "+-" << sqrt(toterr2) << " SF: " << hd->Integral()/tot << std::endl; c = new TCanvas(); sta2->Draw(); hd->Draw("E1,same"); sta2->GetYaxis()->SetRangeUser(options[names[i]].min,options[names[i]].max); hd->GetYaxis()->SetRangeUser(options[names[i]].min,options[names[i]].max); l->Draw(); } }
void singlejeteff(){ Double_t xbins[13] = {10,20,30,35,40,45,50,60,80,90,100,150,200}; int nbins = 12; TFile* g = new TFile("oct9/effoct11.root"); g->TFile::Open(); TH1F *h = (TH1F*)g->Get("Denom"); h->Sumw2(); h->Rebin(2,"hnew"); TH1F *h20 = (TH1F*)g->Get("a4tt/hista4tt15"); //h20->Sumw2(); h20->Rebin(nbins,"hnew20",xbins); h20->Rebin(2,"hnew20"); TH1F *h20h = (TH1F*)g->Get("a4ttjes/hista4ttjes35"); //h20h->Sumw2(); h20h->Rebin(nbins,"hnew20h",xbins); h20h->Rebin(2,"hnew20h"); TGraphAsymmErrors *h5=new TGraphAsymmErrors(hnew20,hnew); h5->Draw("AP"); h5->SetMarkerStyle(20); //h5->SetMarkerSize(1.6); h5->SetMaximum(1.2); //to set the y axis maximum h5->SetMinimum(0.1); // to set the y axis minimum h5->GetXaxis()->SetRangeUser(0.,120.); h5->GetXaxis()->SetTitle("Leading jet p_{T,offline} (EM+JES) [GeV]"); h5->GetYaxis()->SetTitle("Efficiency"); TGraphAsymmErrors *h6=new TGraphAsymmErrors(hnew20h,hnew); h6->Draw("P,same"); h6->SetMarkerStyle(22);h6->SetMarkerColor(2);h6->SetLineColor(2);h6->SetLineStyle(2); TPaveText *pt = new TPaveText(0.506182,0.4016529,0.75163,0.65,"blNDC"); pt->SetBorderSize(0); pt->SetFillColor(0); pt->SetTextFont(42); pt->SetTextSize(0.05); pt->AddText("| #eta_{offline} | <2.8"); pt->Draw("same"); TLegend *leg = new TLegend(0.506182,0.2016529,0.75163,0.4,"","brNDC");leg->SetFillColor(kWhite); leg->SetBorderSize(0); leg->SetTextSize(0.05); leg->SetTextFont(42); leg->AddEntry(h5,"L2FS EM J15"); leg->AddEntry(h6,"L2FS EM+JES J35"); leg->SetBorderSize(0); leg->SetTextSize(0.05); leg->SetTextFont(42); leg->Draw("same"); //c1->SetGridx(); c1->SetGridy(); // c1->SetGridx(); c1->SetGridy(); //c1->SetLogx(1); //h6->Draw("HIST,C,same");h6->SetLineColor(2); //c1->SetGridx(); c1->SetGridy(); //TH1F *h5 = new TH1F("h5","L2FS_6j25 Efficiency",nbins,xbins); // TH1F *h5 = new TH1F("h5","L2FS_6j25 Efficiency",125,0,500); // h5->Divide(hnew20,hnew,1,1,"B"); }
void plotFR_QCD(){ gROOT->Reset(); gROOT->SetStyle("Plain"); gStyle->SetStatFormat("6.4f"); gStyle->SetFitFormat("6.4f"); int BoxValue = 11111111; //4680; gStyle->SetOptFit(11); gStyle->SetOptDate(0); gStyle->SetOptTitle(0); //gStyle->SetOptStat(BoxValue); gStyle->SetOptStat(0); gStyle->SetPadBorderMode(0); gStyle->SetCanvasColor(0); //(10); gStyle->SetPadLeftMargin(0.15); gStyle->SetPadBottomMargin(0.15); gStyle->SetPalette(0); TPaveLabel pl; TLatex lt; lt.SetTextFont(70); lt.SetTextAlign(12); lt.SetTextSize(0.07); lt.SetTextColor(1); TPaveText* tText1 = new TPaveText(0.70, 0.90, 0.90, 0.95, "brNDC"); tText1->SetBorderSize(0); tText1->SetFillColor(0); tText1->SetFillStyle(0); TText *t1 = tText1->AddText("(13 TeV)"); tText1->SetTextSize(0.035); //tText1->Draw(); //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ TPaveText* tText2 = new TPaveText(0.2, 0.90, 0.4, 0.95, "brNDC"); tText2->SetBorderSize(0); tText2->SetFillColor(0); tText2->SetFillStyle(0); TText *t2 = tText2->AddText("CMS Spring15 Simulation"); tText2->SetTextSize(0.035); //tText2->Draw(); TLegend *leg = new TLegend(0.17, 0.77, 0.4, 0.85); leg->SetBorderSize(0.0); leg->SetMargin(0.3); leg->SetFillColor(0); leg->SetFillStyle(10); leg->SetLineColor(0); Float_t tsize2 = 0.03; leg->SetTextSize(tsize2); TFile *_file0 = TFile::Open("ZprimetoMuMu-MC-CMSSW745_FR_QCD_25ns.root"); TH1F *num; _file0->GetObject("h1_Num_Pt_w",num); TH1F *den; _file0->GetObject("h1_Den_Pt_w",den); TH1F *numMB; _file0->GetObject("h1_Num_Pt_Barrel_w",numMB); TH1F *denMB; _file0->GetObject("h1_Den_Pt_Barrel_w",denMB); TH1F *numME; _file0->GetObject("h1_Num_Pt_EndCap_w",numME); TH1F *denME; _file0->GetObject("h1_Den_Pt_EndCap_w",denME); double Nbins = num->GetNbinsX(); cout << "Nbins=" << Nbins << endl; int nRebin=10; num->Rebin(nRebin); den->Rebin(nRebin); numMB->Rebin(nRebin); denMB->Rebin(nRebin); numME->Rebin(nRebin); denME->Rebin(nRebin); // TH1F *fake=new TH1F("fake","fake",Nbins/nRebin,0.,2000.); TH1F *fakeMB=new TH1F("fakeMB","fakeMB",Nbins/nRebin,0.,2000.); TH1F *fakeME=new TH1F("fakeME","fakeME",Nbins/nRebin,0.,2000.); cout << "Bins=" << Nbins/nRebin << endl; int* arraysize = new int[1]; arraysize[0]=Nbins/nRebin; Float_t xMB[arraysize[0]],yMB[arraysize[0]],exlMB[arraysize[0]],exhMB[arraysize[0]],eylMB[arraysize[0]],eyhMB[arraysize[0]]; for (unsigned int i=1; i<=Nbins/nRebin;i++){ // All Muon if (denMB->GetBinContent(i)>0.) { fakeMB->SetBinContent(i,double(numMB->GetBinContent(i)/denMB->GetBinContent(i))); xMB[i-1]=fakeMB->GetBinCenter(i); yMB[i-1]=fakeMB->GetBinContent(i); exlMB[i-1]=0.; exhMB[i-1]=0.; //eyhMB[i-1]=+0.5 + sqrt(fakeMB->GetBinContent(i)+0.25); //eylMB[i-1]=-0.5 + sqrt(fakeMB->GetBinContent(i)+0.25); if (double(numMB->GetBinContent(i)/denMB->GetBinContent(i))<1.){ fakeMB->SetBinError(i, sqrt( double(numMB->GetBinContent(i)/denMB->GetBinContent(i))*(1-double(numMB->GetBinContent(i)/denMB->GetBinContent(i)))/double(denMB->GetBinContent(i)) ) );} else fakeMB->SetBinError(i, sqrt( double(numMB->GetBinContent(i)/pow(denMB->GetBinContent(i),2)+1./pow(denMB->GetBinContent(i),3)))); eyhMB[i-1]=fakeMB->GetBinError(i)/2.; eylMB[i-1]=fakeMB->GetBinError(i)/2.; } else { fakeMB->SetBinContent(i,0.); fakeMB->SetBinError(i,0.); xMB[i-1] = 0.; eylMB[i-1] = 0.; eyhMB[i-1] = 0.; exlMB[i-1]=0.; exhMB[i-1]=0.; } } //TGraphAsymmErrors *grMB = new TGraphAsymmErrors(Nbins/nRebin,xMB,yMB,exlMB,exhMB,eylMB,eyhMB); TGraphAsymmErrors *grMB = new TGraphAsymmErrors(); grMB->BayesDivide(numMB,denMB); //TGraphAsymmErrors *grMB = new TGraphAsymmErrors(numMB,denMB); grMB->SetMarkerColor(2); grMB->SetMarkerStyle(20); grMB->SetMarkerSize(0.95); //TF1* fn1 = new TF1("fn1","pol1",10,100); //fn1->SetLineColor(1); //grMB->Fit("fn1","R,smaes"); //TF1* fn2 = new TF1("fn2",FittingFunc1,100,2000.0,3); //fn2->SetLineColor(1); //grMB->Fit("fn2","R"); // ME Float_t xME[arraysize[0]],yME[arraysize[0]],exlME[arraysize[0]],exhME[arraysize[0]],eylME[arraysize[0]],eyhME[arraysize[0]]; for (unsigned int i=1; i<=Nbins/nRebin;i++){ // All Muon if (denME->GetBinContent(i)>0.) { fakeME->SetBinContent(i,double(numME->GetBinContent(i)/denME->GetBinContent(i))); xME[i-1]=fakeME->GetBinCenter(i); yME[i-1]=fakeME->GetBinContent(i); exlME[i-1]=0.; exhME[i-1]=0.; //eyhME[i-1]=+0.5 + sqrt(fakeME->GetBinContent(i)+0.25); //eylME[i-1]=-0.5 + sqrt(fakeME->GetBinContent(i)+0.25); if (double(numME->GetBinContent(i)/denME->GetBinContent(i))<1.){ fakeME->SetBinError(i, sqrt( double(numME->GetBinContent(i)/denME->GetBinContent(i))*(1-double(numME->GetBinContent(i)/denME->GetBinContent(i)))/double(denME->GetBinContent(i)) ) ); } else fakeME->SetBinError(i, sqrt( double(numME->GetBinContent(i)/pow(denME->GetBinContent(i),2)+1./pow(denME->GetBinContent(i),3)))); eyhME[i-1]=fakeME->GetBinError(i)/2.; eylME[i-1]=fakeME->GetBinError(i)/2.; } else { fakeME->SetBinContent(i,0.); fakeME->SetBinError(i,0.); xME[i-1] = 0.; eylME[i-1] = 0.; eyhME[i-1] = 0.; exlME[i-1]=0.; exhME[i-1]=0.; } } //TGraphAsymmErrors *grME = new TGraphAsymmErrors(Nbins/nRebin,xME,yME,exlME,exhME,eylME,eyhME); TGraphAsymmErrors *grME = new TGraphAsymmErrors(); grME->BayesDivide(numME,denME); grME->SetMarkerColor(4); grME->SetMarkerStyle(20); grME->SetMarkerSize(0.95); TH2F *hframe=NULL,*hframe2=NULL; hframe= new TH2F("hframe","hframe",500,50.,2000.,500,0.0001,2.0); hframe->GetYaxis()->SetTitle("Fake rate"); hframe->GetXaxis()->SetTitle("p_{T} (GeV)"); hframe->GetXaxis()->SetTitleOffset(1.7); hframe->GetYaxis()->SetTitleOffset(1.7); TCanvas *c1 = new TCanvas("c1","c1",800,600); c1->SetLogy(1); c1->SetLogx(1); //c1->SetGrid(); gPad->SetTopMargin(0.12); gPad->SetLeftMargin(0.15); gPad->SetFillColor(0); gPad->SetTickx(); gPad->SetTicky(); // gPad->SetGridy(); //gPad->SetGridx(); c1->SetLogy(1); c1->SetLogx(1); // c1->SetGrid(); grMB->SetLineColor(1); grMB->GetXaxis()->SetTitleOffset(1.7); grMB->GetYaxis()->SetTitleOffset(1.7); grMB->GetXaxis()->SetLabelSize(0.03); grMB->GetYaxis()->SetLabelSize(0.03); grMB->GetXaxis()->SetTitle("p_{T} (GeV)"); grMB->GetYaxis()->SetTitle("Fake rate"); grMB->GetXaxis()->SetTitleOffset(1.5); grMB->GetYaxis()->SetTitleOffset(2.0); grMB->GetXaxis()->SetTitleSize(0.05); grMB->GetXaxis()->SetLabelSize(0.03); grMB->GetYaxis()->SetLabelSize(0.03); leg->AddEntry(grMB,"barrel","p"); grME->SetLineColor(1); grME->GetXaxis()->SetTitleOffset(1.7); grME->GetYaxis()->SetTitleOffset(1.7); grME->GetXaxis()->SetLabelSize(0.03); grME->GetYaxis()->SetLabelSize(0.03); grME->GetXaxis()->SetTitle("p_{T} (GeV)"); grME->GetYaxis()->SetTitle("Fake rate"); grME->GetXaxis()->SetTitleOffset(1.5); grME->GetYaxis()->SetTitleOffset(2.0); grME->GetXaxis()->SetTitleSize(0.05); grME->GetXaxis()->SetLabelSize(0.03); grME->GetYaxis()->SetLabelSize(0.03); leg->AddEntry(grME,"endcap","p"); hframe->Draw(); grMB->Draw("Psame"); grME->Draw("Psame"); tText1->Draw("same"); tText2->Draw("same"); leg->Draw("same"); c1->SaveAs("FR_QCD.png"); c1->SaveAs("FR_QCD.pdf"); c1->SaveAs("FR_QCD.eps"); //c1->SaveAs("FR_QCD.root"); TFile *fileX = new TFile("FR_QCD.root", "RECREATE"); fileX->cd(); numMB->Write(); denMB->Write(); numME->Write(); denME->Write(); //grMB->Write(); //grME->Write(); fileX->Write(); fileX->Close(); }
int main ( int argc, char *argv[] ) { StopStyle(); std::vector<std::string> vDec; //vDec.push_back("PhaseI"); //vDec.push_back("PhaseII3"); //vDec.push_back("PhaseII4"); vDec.push_back("PhaseI_0PU"); vDec.push_back("PhaseI_140PU"); vDec.push_back("PhaseII3_140PU"); vDec.push_back("PhaseII4_140PU"); std::vector<std::string> vLep; vLep.push_back("EleEta"); //vLep.push_back("ElePt"); vLep.push_back("MuonEta"); //vLep.push_back("MuonPt"); //vLep.push_back("TauEta"); //vLep.push_back("TauPt"); //vLep.push_back("JetEta"); //vLep.push_back("JetPt"); //vLep.push_back("JetPt"); //vLep.push_back("MET"); //vLep.push_back("MHT"); int cut = 0; //int cut = 5; //Before lepton veto //int cut = 14; //After METCut std::vector<int> VColor; VColor.push_back(1); VColor.push_back(2); VColor.push_back(4); VColor.push_back(6); VColor.push_back(kGreen+2); VColor.push_back(kOrange+9); VColor.push_back(60); TCanvas *c1 = new TCanvas("fd", "dfdf", 600, 500); TLegend *lg = NULL; //c1->SetGridx(); //c1->SetGridy(); for (int j = 0; j < vLep.size(); ++j) { if (vLep.at(j).find("Pt") != std::string::npos) lg = new TLegend(0.602349,0.1631356,0.8389262,0.4576271,NULL,"brNDC"); else if (vLep.at(j).find("EleEta") != std::string::npos ) //lg = new TLegend(0.3691275,0.1751055,0.6057047,0.4683544,"W(e#nu) + jets","brNDC"); lg = new TLegend(0.3238255,0.1673729,0.5486577,0.4618644,"W(e#nu) + jets","brNDC"); else if (vLep.at(j).find("MuonEta") != std::string::npos) //lg = new TLegend(0.3691275,0.1751055,0.6057047,0.4683544,"W(#mu#nu) + jets","brNDC"); lg = new TLegend(0.3238255,0.1673729,0.5486577,0.4618644,"W(#mu#nu) + jets","brNDC"); //lg = new TLegend(0.3791946,0.1737288,0.6157718,0.4682203,NULL,"brNDC"); else if (vLep.at(j).find("JetEta") != std::string::npos) lg = new TLegend(0.3657718,0.7139831,0.6241611,0.9533898,NULL,"brNDC"); else if (vLep.at(j).find("TauEta") != std::string::npos) lg = new TLegend(0.3842282,0.654661,0.6208054,0.9491525,NULL,"brNDC"); else lg = new TLegend(0.3791946,0.1737288,0.6157718,0.4682203,NULL,"brNDC"); //else if (vLep.at(j).find("EleEta") != std::string::npos) lg->SetBorderSize(0); lg->SetFillStyle(0); //transparent hollow? lg->SetTextFont(62); //lg->SetTextSize(0.03); lg->SetTextSize(0.04); double ymin = 0.0; double ymax = 0.0; TAxis *yaxis = NULL; TAxis *xaxis = NULL; for (int i = 0; i < vDec.size(); ++i) { char pu[10]; char det[10]; sscanf(vDec.at(i).c_str(), "%[^_]_%s", det, pu); std::cout << " pu " << pu << " "<< strcmp(pu, "0PU") << std::endl; std::string pileup ="" ; if (strcmp(pu, "0PU") == 0) pileup = "NoPileUp"; if (strcmp(pu, "50PU") == 0) pileup = "50PileUp"; if (strcmp(pu, "140PU") == 0) pileup = "140PileUp"; std::cout << " pileup " << pileup <<" dec " << det << std::endl; HTSample *HT = new HTSample("LPC_MHTCUT/", "Wlv*_14TEV_HT", pileup, det); HT->InitSample(3000*1000); c1->cd(); c1->Update(); TH1F* reco = NULL; TH1F* gen = NULL; //TH2D* reco = NULL; //TH2D* gen = NULL; std::cout << " " << vLep.at(j) << std::endl; if (vLep.at(j) != "MET" && vLep.at(j) != "MHT") { TString reconame = "AppMatched"+vLep.at(j); TString genname = "AppGen"+vLep.at(j); //reco = (TH2D*)HT->GetTH2D(reconame.Data(), cut); //gen = (TH2D*)HT->GetTH2D(genname.Data(), cut); reco = (TH1F*)HT->GetTH1(reconame.Data(), cut); gen = (TH1F*)HT->GetTH1(genname.Data(), cut); } else { //reco = (TH1F*)HT->GetTH1(vLep.at(j), cut); //gen = (TH1F*)HT->GetTH1("GenMet"); } if (vLep.at(j).find("Pt") != std::string::npos) { reco->Rebin(5); gen->Rebin(5); } //TH1F* reco = (TH1F*)HT->GetTH1("JetEta", cut); //TH1F* gen = (TH1F*)HT->GetTH1("GenJetEta", cut); //TH1F* reco = (TH1F*)HT->GetTH1("MuonPt", cut); //reco->Rebin(5); //TH1F* gen = (TH1F*)HT->GetTH1("GenMuonPt", cut); //gen->Rebin(5); //TH1F* reco = (TH1F*)HT->GetTH1("ElePt", cut); // //TH1F* gen = (TH1F*)HT->GetTH1("GenElePt", cut); reco->Divide(gen); reco->SetTitle(""); //gen->Draw(); //gen->SetLineColor(1); reco->SetLineWidth(3); reco->SetLineColor(VColor.at(i)); ymin = ymin < reco->GetMinimum() ? ymin : reco->GetMinimum(); ymax = ymax > reco->GetMaximum() ? ymax : reco->GetMaximum(); if (i == 0) { yaxis = reco->GetYaxis(); xaxis = reco->GetXaxis(); reco->Draw(); } else { reco->Draw("same"); } reco->GetYaxis()->SetTitle("Efficiency"); if (vDec.at(i).find("PU") != std::string::npos) { std::cout << " vDec.at(i)" << vDec.at(i) << std::endl; std::cout<<"Run to \033[0;31m"<<__func__<<"\033[0m at \033[1;36m"<< __FILE__<<"\033[0m, line \033[0;34m"<< __LINE__<<"\033[0m"<< std::endl; if (vDec.at(i) == "PhaseI_0PU") { lg->AddEntry(reco, "Phase I, <PU>=0", "fl"); reco->SetLineColor(1); } if (vDec.at(i) == "PhaseI_140PU") { lg->AddEntry(reco, "Phase I, <PU>=140", "fl"); reco->SetLineColor(4); } if (vDec.at(i) == "PhaseII3_140PU") { lg->AddEntry(reco, "Phase II Conf3, <PU>=140", "fl"); //lg->AddEntry(reco, "PhaseII3 <PU>=140", "fl"); reco->SetLineColor(kGreen+2); } if (vDec.at(i) == "PhaseII4_140PU") { lg->AddEntry(reco, "Phase II Conf4, <PU>=140", "fl"); reco->SetLineColor(2); } //TString leg = vDec.at(i); //lg->AddEntry(reco, leg.ReplaceAll("_", " "), "l"); } TString xlabel = reco->GetXaxis()->GetTitle(); std::cout << xlabel << std::endl; if (xlabel =="#Pt_{Matched m} [GeV]") std::cout<<"Run to \033[0;31m"<<__func__<<"\033[0m at \033[1;36m"<< __FILE__<<"\033[0m, line \033[0;34m"<< __LINE__<<"\033[0m"<< std::endl; if (xlabel =="#eta_{Matched e}" ) xlabel = "#eta_{e}"; if (xlabel =="#eta_{Matched m}" ) xlabel = "#eta_{#mu}"; if (xlabel =="#eta_{Matched t}" ) xlabel = "#eta_{t}"; if (xlabel =="#Pt_{Matched e} [GeV] " ) xlabel = "#P_{T}^{e} [GeV]"; if (xlabel =="#Pt_{Matched m} [GeV] " ) xlabel = "#P_{T}^{#mu} [GeV]"; if (xlabel =="#Pt_{Matched t} [GeV] " ) xlabel = "#P_{T}^{t} [GeV]"; reco->GetXaxis()->SetTitle(xlabel); reco->GetYaxis()->SetTitleOffset(1.0); reco->GetXaxis()->SetTitleOffset(0.9); reco->GetYaxis()->SetTitleSize(0.06); reco->GetXaxis()->SetTitleSize(0.06); reco->GetYaxis()->SetLabelSize(0.05); reco->GetXaxis()->SetLabelSize(0.05); //reco->GetYaxis()->SetRangeUser(0.1*ymin, 5*ymax); //c1->Print("Pt.png"); //c1->Print("MuonEta_0.png"); //c1->Print("EleEta_0.png"); //TH1F* jet = (TH1F*)HT->GetTH1("JetPTScale", cut); //jet->Draw(); //c1->Print("Jet.png"); delete HT; } yaxis->SetRangeUser(0.8*ymin, 1.2*ymax); xaxis->SetRangeUser(-4.5, 4.5); lg->Draw(); DrawTitle(); c1->RedrawAxis(); std::stringstream ss; ss << "Efficiency_"<<vLep.at(j)<< "_"<< cut<< ".png"; c1->Print(ss.str().c_str()); ss.str(""); ss << "Efficiency_"<<vLep.at(j)<< "_"<< cut<< ".pdf"; c1->Print(ss.str().c_str()); ss.str(""); ss << "Efficiency_"<<vLep.at(j)<< "_"<< cut<< ".C"; c1->Print(ss.str().c_str()); ss.str(""); ss << "Efficiency_"<<vLep.at(j)<< "_"<< cut<< ".root"; c1->Print(ss.str().c_str()); } return EXIT_SUCCESS; } // ---------- end of function main ----------
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 macro_MakeFRClosureTestRatio() { // parameters ////////////////////////////////////////////////////////////// // luminosity of data const float lumi = 3694; string inputFilePrefix = "invMassHistos"; // lumi and .root will be added //string inputFilePrefix = "test"; // which closure test ratios should be plotted? bool plotClosureTest[4]; plotClosureTest[0] = false; // no corrections plotClosureTest[1] = false; // GSF electrons not passing HEEP plotClosureTest[2] = false; // all above + HEEP-GSF corrected with DY contribuion plotClosureTest[3] = true; // all above + GSF-GSF corrected with W+jet and gamma+jet contribution // which histograms should be plotted? bool plotHisto[4]; plotHisto[0] = true; // EB-EB + EB-EE plotHisto[1] = true; // EB-EB plotHisto[2] = true; // EB-EE plotHisto[3] = true; // EE-EE int font = 42; //////////////////////////////////////////////////////////////////////////// // const int rebin = 10; float massMin = 50; float massMax = 1500; int nBins = 1450; vector<pair<float, float> > binning; // VARIABLE BINNING binning.push_back(make_pair(100, 10)); binning.push_back(make_pair(500, 25)); binning.push_back(make_pair(1500, 250)); // CONSTANT BINNING // binning.push_back(make_pair(massMax, 50)); vector<float> bins; bins.push_back(massMin); for (vector<pair<float,float> >::iterator it = binning.begin(); it < binning.end(); ++it) { while (bins.back() < it->first) bins.push_back(bins.back() + it->second); } if (bins.back() < massMax) bins.push_back(massMax); nBins = bins.size() - 1; Double_t binArray[nBins + 1]; for (int i = 0; i <= nBins; ++i) binArray[i] = (Double_t)bins.at(i); stringstream sStream; sStream << "Photon_Run2012A-PromptReco-v1+23May2012-v2+DoublePhotonHighPt_Run2012B_AOD_Cert_190456-195775_8TeV_PromptReco+May23ReReco_Collisions12_JSON_gct1_32_" << lumi << "pb-1"; //sStream << lumi << "pb-1"; TString folderDataHisto = sStream.str().c_str(); // select histograms dynamically depending on state of correction ////////// vector<TString> folderHeepGsfHisto; folderHeepGsfHisto.push_back(sStream.str().c_str()); folderHeepGsfHisto.push_back(sStream.str().c_str()); folderHeepGsfHisto.push_back("combinations"); folderHeepGsfHisto.push_back("combinations"); vector<TString> folderGsfGsfHisto; folderGsfGsfHisto.push_back(sStream.str().c_str()); folderGsfGsfHisto.push_back(sStream.str().c_str()); folderGsfGsfHisto.push_back(sStream.str().c_str()); folderGsfGsfHisto.push_back("combinations"); vector<TString> heepGsfHisto; heepGsfHisto.push_back("histoHeepGsfMassFR"); heepGsfHisto.push_back("histoHeepGsfMassNoHeepFR"); heepGsfHisto.push_back("histoHeepGsfCorr"); heepGsfHisto.push_back("histoHeepGsfCorr"); vector<TString> gsfGsfHisto; gsfGsfHisto.push_back("histoGsfGsfMassFR"); gsfGsfHisto.push_back("histoGsfGsfMassNoHeepFR"); gsfGsfHisto.push_back("histoGsfGsfMassNoHeepFR"); gsfGsfHisto.push_back("histoGsfGsfCorr"); //////////////////////////////////////////////////////////////////////////// vector<TString> canvasName; canvasName.push_back("ratioFR"); canvasName.push_back("ratioFRNoHeep"); canvasName.push_back("ratioFRCorrDY"); canvasName.push_back("ratioFRCorrFull"); vector<TString> canvasTitle; canvasTitle.push_back("Fake rate ratio GSF-GSF / HEEP-GSF - uncorrected"); canvasTitle.push_back("Fake rate ratio GSF-GSF / HEEP-GSF - non HEEP"); canvasTitle.push_back("Fake rate ratio GSF-GSF / HEEP-GSF - DY corrected"); canvasTitle.push_back("Fake rate ratio GSF-GSF / HEEP-GSF - full corrected"); vector<TString> acroSuffix; acroSuffix.push_back(""); acroSuffix.push_back("BB"); acroSuffix.push_back("BE"); acroSuffix.push_back("EE"); vector<TString> suffix; suffix.push_back(""); suffix.push_back(" EB-EB"); suffix.push_back(" EB-EE"); suffix.push_back(" EE-EE"); sStream.str(""); sStream << inputFilePrefix << lumi << "pb-1.root"; TFile input(sStream.str().c_str(), "read"); input.cd(); cout << endl << "Input file: " << sStream.str() << endl; // to keep the histogram when the file is closed TH1::AddDirectory(kFALSE); TH1::SetDefaultSumw2(kTRUE); for (unsigned int j = 0; j < 4; ++j) { if (!plotClosureTest[j]) continue; for (unsigned int p = 0; p < 4; ++p) { if (!plotHisto[p]) continue; TCanvas *c0 = new TCanvas(canvasName[j] + acroSuffix[p], canvasTitle[j] + suffix[p], 100, 100, 800, 600); c0->cd(); c0->SetBorderMode(0); c0->SetFrameBorderMode(0); c0->SetFillColor(0); c0->SetFrameFillColor(0); gStyle->SetOptStat(0); gStyle->SetPadTickY(1); // get the histograms input.cd(folderGsfGsfHisto[j]); TH1F *numHisto = (TH1F *)gDirectory->Get(gsfGsfHisto[j] + acroSuffix[p]); input.cd(folderHeepGsfHisto[j]); TH1F *denomHisto = (TH1F *)gDirectory->Get(heepGsfHisto[j] + acroSuffix[p]); TH1F *numHistoRebinned = (TH1F *)numHisto->Rebin(nBins, "numHistoRebinned" + acroSuffix[p], binArray); TH1F *denomHistoRebinned = (TH1F *)denomHisto->Rebin(nBins, "denomHistoRebinned" + acroSuffix[p], binArray); TH1F *ratioHisto = new TH1F("histoRatioCorr" + acroSuffix[p], canvasTitle[j] + suffix[p], nBins, binArray); ratioHisto->Divide(numHistoRebinned, denomHistoRebinned); ratioHisto->SetLineColor(4); ratioHisto->SetMarkerColor(4); ratioHisto->SetMarkerStyle(20); ratioHisto->Draw(); ratioHisto->Fit("pol0", "+", "lep", 120, 500); sStream.str(""); sStream << "#sqrt{s} = 7TeV, #int L dt = " << lumi << "pb^{-1}"; TPaveLabel *label0 = new TPaveLabel(0.6, 0.7, 0.9, 0.8, sStream.str().c_str(), "brNDC"); label0->SetFillColor(0); label0->SetFillStyle(0); label0->SetBorderSize(0); label0->SetTextSize(0.30); label0->SetTextFont(font); label0->Draw("sames"); TPaveLabel *label1 = new TPaveLabel(0.6, 0.8, 0.9, 0.9, "CMS preliminary", "brNDC"); label1->SetFillColor(0); label1->SetFillStyle(0); label1->SetBorderSize(0); label1->SetTextSize(0.40); label1->SetTextFont(font); label1->Draw("sames"); //TLegend *legend = new TLegend(0.38, 0.6, 0.53, 0.9); //legend->SetTextSize(0.03); //legend->SetTextFont(font); //legend->SetBorderSize(0); //legend->SetFillStyle(0); //legend->AddEntry(ratioHisto, "Ratio GSF-GSF / HEEP-GSF (non HEEP)", "lep"); //legend->Draw("sames"); } // end loop over eta ranges } // end loop over corrections input.Close(); }
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 HwwNoteFigs(TString filename = "../histo_tmva_new-ntuples-1_160_0.root", int mass = 170, int ReBin = 4, int ysel = 0) { TFile* infile = new TFile(filename.Data(),"READ"); setTDRStyle(0); //BDTD dists TCanvas* c1 = new TCanvas("c1","c1",0,-200,500,500); TH1F* histoBg = histo4->Clone(); histoBg->Add(histo3); histoBg->Add(histo2); histoBg->Add(histo1); TH1F* histo_4 = histo4->Clone(); histo3->Add(histo_4); TH1F* histo_3 = histo3->Clone(); histo2->Add(histo_3); TH1F* histo_2 = histo2->Clone(); histo1->Add(histo_2); histo1->Rebin(ReBin); histo1->SetFillColor(kBlue); histo1->SetFillStyle(1001); histo1->SetLineStyle(0); histo1->SetLineWidth(0); histo2->Rebin(ReBin); histo2->SetFillColor(kMagenta); histo2->SetFillStyle(1001); histo2->SetLineStyle(0); histo2->SetLineWidth(0); histo3->Rebin(ReBin); histo3->SetFillColor(kGreen); histo3->SetFillStyle(1001); histo3->SetLineStyle(0); histo3->SetLineWidth(0); histo4->Rebin(ReBin); histo4->SetFillColor(kCyan); histo4->SetFillStyle(1001); histo4->SetLineStyle(0); histo4->SetLineWidth(0); char YTitle[300]; sprintf(YTitle,"events / bin"); char XTitle[300]; sprintf(XTitle,"BDT Output"); histo0->SetYTitle(YTitle); histo1->SetYTitle(YTitle); histo2->SetYTitle(YTitle); histo3->SetYTitle(YTitle); histo4->SetYTitle(YTitle); histo0->SetXTitle(XTitle); histo1->SetXTitle(XTitle); histo2->SetXTitle(XTitle); histo3->SetXTitle(XTitle); histo4->SetXTitle(XTitle); histo1->SetTitleSize(0.05, "X"); histo1->GetXaxis()->SetTitleFont(62); histo1->GetXaxis()->SetLabelFont(61); histo1->GetYaxis()->SetLabelFont(61); histo1->GetYaxis()->SetTitleOffset(1.3); histo1->SetLabelSize(0.04, "Y"); histo1->SetLabelSize(0.04, "X"); int min = histoBg->FindBin(-1.5); int max = histoBg->FindBin(1.5); histoBg->GetXaxis()->SetRange(min,max); histoBg->SetMarkerStyle(20); histoBg->SetMarkerSize(1.0); histoBg->GetYaxis()->SetTitleOffset(1.40); histo0->SetMarkerStyle(21); histo0->SetMarkerSize(1.0); histoBg->Rebin(ReBin); histo0->Rebin(ReBin); histoBg->SetLineColor(4); histo0->SetLineColor(1); scaleHist(histoBg); scaleHist(histo0); cout << "bg events: " << histoBg->GetSumOfWeights() << endl; cout << "si events: " << histo0->GetSumOfWeights() << endl; histoBg->SetYTitle("Events"); histo1->SetMinimum(0.01); if(ysel == 0) { histo1->Draw("hist"); } else { histo0->Draw("E"); histo1->Draw("hist,same"); } histo2->Draw("hist,same"); histo3->Draw("hist,same"); histo4->Draw("hist,same"); histo0->Draw("E, same"); //histoBg->DrawCopy("hist"); //histo0->DrawCopy("hist,same"); TLegend* leg = new TLegend(0.63, 0.75, 0.92, 0.92); leg->SetFillColor(0); char theSLine[100]; if(mass != 999) sprintf(theSLine,"Signal, m_{H}=%d GeV",mass); else sprintf(theSLine,"WW"); cout << theSLine << endl; leg ->AddEntry(histo0,theSLine); leg ->AddEntry(histo4,"W+Jets, W#gamma","F"); leg ->AddEntry(histo3,"di-boson","F"); leg ->AddEntry(histo2,"t#bar{t}, tW","F"); leg ->AddEntry(histo1,"Drell-Yan","F"); leg->Draw("same"); TString fileOutput1(filename.Data()); TString theLine = "_"; theLine = theLine + "plot.eps"; fileOutput1.ReplaceAll(".root",theLine.Data()); fileOutput1.ReplaceAll("../",""); fileOutput1.ReplaceAll("rootfiles_fastsim/",""); fileOutput1.ReplaceAll("rootfiles_fullsim/",""); c1->SaveAs(fileOutput1.Data()); //return; //-------------------------------- TCanvas* c3 = new TCanvas("c3","c3",550,-200,500,500); c3->SetLogx(); c3->SetLogy(); gPad->SetGrid(1,1); TGraphErrors* gBDTD = makeGraphFromHists(histo0, histoBg); gBDTD->Draw("APXl"); TH1* zBDTD = gBDTD->GetHistogram(); zBDTD->SetXTitle("Signal Events"); zBDTD->SetYTitle("Signal/Background"); //zBDTD->SetYTitle("Background Events"); //zBDTD->DrawCopy(); TLegend* leg3 = new TLegend(0.7, 0.7, 0.9, 0.9); leg3->SetFillColor(0); leg3->AddEntry(gBDTD,theSLine,"lp"); leg3->Draw("same"); TString fileOutput2(filename.Data()); theLine = "_"; theLine = theLine + "counts.eps"; fileOutput2.ReplaceAll(".root",theLine.Data()); fileOutput2.ReplaceAll("../",""); fileOutput2.ReplaceAll("rootfiles_fastsim/",""); fileOutput2.ReplaceAll("rootfiles_fullsim/",""); c3->SaveAs(fileOutput2.Data()); }
void AllInOne_combineLepton(const std::string& dataset,int btag=0, double timesX=1, bool useNewShape=false){ std::string useNewShapeText = (useNewShape) ? "_newshape" : ""; char wsFileName[700]; sprintf(wsFileName,"datacards/400/hzz2l2q_ee%db.input.root",btag); //sprintf(wsFileName,"PROVA/datacards_%s%s/hzz2l2q_ee%db.input.root",dataset.c_str(), useNewShapeText.c_str(),btag); gSystem->Load("libRooFit"); gSystem->Load("libFFTW"); string histoName[3]; histoName[0]="mZZ_kinfit_hiMass_0btag"; histoName[1]="mZZ_kinfit_hiMass_1btag"; histoName[2]="mZZ_kinfit_hiMass_2btag"; string btagName[3]={"0b","1b","2b"}; double LumiScale=0.; if( dataset=="Run2011A_FULL" ) LumiScale = 2100.; else if( dataset=="LP11" ) LumiScale = 1600.; else { std::cout << "Unknown dataset '" << dataset << "'. Exiting." << std::endl; } RooDataSet *data_bkg; RooDataSet *data_temp; TFile *file; string cutString[3]; cutString[0]="nBTags==0 && (mZjj>75 && mZjj<105) && mZZ>183"; cutString[1]="nBTags==1 && (mZjj>75 && mZjj<105) && mZZ>183"; cutString[2]="nBTags==2 && (mZjj>75 && mZjj<105) && mZZ>183"; int binWidth=20; int highBin=750; int lowBin=150; //double muonEff[3]={.576,.548,.489}; //double expSig[3]; //expSig[0]=5.65*LumiScale ; //expSig[1]=4.89*LumiScale ; //expSig[2]=2.37*LumiScale ; char alphaFileName[200]; sprintf( alphaFileName, "alphaFile_%s_%dbtag_ALL.root", dataset.c_str(), btag); TFile* alphaFile = TFile::Open(alphaFileName); TTree* treeSidebandsDATA_alphaCorr = (TTree*)alphaFile->Get("sidebandsDATA_alpha"); TH1D* h1_mZZ_sidebands_alpha = new TH1D("mZZ_sidebands_alpha", "", 65, 150., 800.); char sidebandsCut_alpha[500]; sprintf(sidebandsCut_alpha, "eventWeight_alpha*(isSidebands && nBTags==%d)", btag); treeSidebandsDATA_alphaCorr->Project("mZZ_sidebands_alpha", "mZZ", sidebandsCut_alpha); float expBkg = h1_mZZ_sidebands_alpha->Integral(); std::cout << "++++ expBkg: " << expBkg << std::endl; stringstream convert; // --------------------- measurable (ZZ invariant mass) ---------------- string temp; temp="m_{ZZ}"; RooRealVar mZZ("mZZ",temp.c_str(),lowBin,highBin); RooRealVar nBTags("nBTags","nBTags",-1.,3.); RooRealVar leptType("leptType","leptType",0,1); RooRealVar mZjj("mZjj","mZjj",0,200.); // ----------------- get parameters from data cards! ----------------- TFile *wsFile = new TFile(wsFileName); RooWorkspace *ws = (RooWorkspace*) wsFile->Get("w"); // ==================== defining bkg PDF ========================== // ------------------------ fermi ------------------------------ RooRealVar cutOff("cutOff","position of fermi",ws->var("cutOff_BKG")->getVal()); cutOff.setConstant(kTRUE); RooRealVar beta("beta","width of fermi",ws->var("beta_BKG")->getVal()); beta.setConstant(kTRUE); RooFermi fermi("fermi","fermi function",mZZ,cutOff,beta); // -------------------- double gauss --------------------------- temp="CMS_hzz2l2q_bkg"+btagName[btag]+"p1"; RooRealVar m("m","m",ws->var(temp.c_str())->getVal()); m.setConstant(kTRUE); temp="CMS_hzz2l2q_bkg"+btagName[btag]+"p2"; RooRealVar wdth("wdth","wdth",ws->var(temp.c_str())->getVal()); wdth.setConstant(kTRUE); temp="CMS_hzz2l2q_bkg"+btagName[btag]+"p3"; RooRealVar n("n","n",ws->var(temp.c_str())->getVal()); n.setConstant(kTRUE); temp="CMS_hzz2l2q_bkg"+btagName[btag]+"p4"; RooRealVar alpha("alpha","alpha",ws->var(temp.c_str())->getVal()); alpha.setConstant(kTRUE); temp="CMS_hzz2l2q_bkg"+btagName[btag]+"p5"; RooRealVar theta("theta","theta",ws->var(temp.c_str())->getVal()); theta.setConstant(kTRUE); RooCB CB("CB","Crystal ball",mZZ,m,wdth,alpha,n,theta); RooProdPdf background("background","background",RooArgSet(fermi,CB)); // ------------------ get data -------------------------- // for reading sideband extrapolated data... std::string fileName = "HZZlljjRM_DATA_" + dataset + "_optLD_looseBTags_v2_ALL.root"; file = new TFile(fileName.c_str()); //file = new TFile("../HZZlljjRM_DATA_Run2011A_FULL_optLD_looseBTags_v2_ALL.root"); TTree* t=(TTree*)file->Get("tree_passedEvents"); data_bkg=new RooDataSet("data_bkg","data_bkg",t, RooArgSet(mZZ,leptType,nBTags,mZjj), cutString[btag].c_str()); // --------- draw MC data ------------------- RooPlot *plot_MCbkg = mZZ.frame(lowBin,highBin,(int)(highBin-lowBin)/binWidth); //----------------------------------------------------------------------- TCanvas *c2 = new TCanvas("c2","c2",600,600); TPaveText* cmslabel = new TPaveText( 0.145, 0.953, 0.6, 0.975, "brNDC" ); cmslabel->SetFillColor(kWhite); cmslabel->SetTextSize(0.038); cmslabel->SetTextAlign(11); cmslabel->SetTextFont(62); cmslabel->SetBorderSize(0); char lumilabel[500]; sprintf( lumilabel, "CMS Preliminary 2011, %.1f fb^{-1}", LumiScale/1000.); cmslabel->AddText(lumilabel); TPaveText* label_sqrt = new TPaveText(0.7,0.953,0.96,0.975, "brNDC"); label_sqrt->SetFillColor(kWhite); label_sqrt->SetTextSize(0.038); label_sqrt->SetTextFont(42); label_sqrt->SetTextAlign(31); // align right label_sqrt->SetBorderSize(0); label_sqrt->AddText("#sqrt{s} = 7 TeV"); //----------------------------------------------------------------------- background.plotOn(plot_MCbkg,Normalization(expBkg)); data_bkg->plotOn(plot_MCbkg,Binning((int)(highBin-lowBin)/binWidth)); // -------------------- get histograms ----------------- TFile *ZjetsFile = new TFile("HZZlljjRM_DYJetsToLL_TuneZ2_M-50_7TeV-madgraph-tauola_Summer11-PU_S4_START42_V11-v1_optLD_looseBTags_v2_ALL.root"); TFile *TTFile = new TFile("HZZlljjRM_TT_TW_TuneZ2_7TeV-powheg-tauola_Summer11-PU_S4_START42_V11-v1_optLD_looseBTags_v2_ALL.root"); TFile *VVFile = new TFile("HZZlljjRM_VV_TuneZ2_7TeV-pythia6-tauola_Summer11-PU_S4_START42_V11-v1_optLD_looseBTags_v2_ALL.root"); TFile *H400File = new TFile("HZZlljjRM_GluGluToHToZZTo2L2Q_M-400_7TeV-powheg-pythia6_Summer11-PU_S4_START42_V11-v1_optLD_looseBTags_v2_ALL.root"); TH1F *hZjets =(TH1F*)ZjetsFile->Get(histoName[btag].c_str()); hZjets->SetName("hZjets"); hZjets->Scale(LumiScale); hZjets->Rebin(binWidth); hZjets->SetFillColor(30); TH1F *hTT =(TH1F*)TTFile->Get(histoName[btag].c_str()); hTT->SetName("hTT"); convert << binWidth; temp=";m_{ZZ} [GeV]; Events / "+convert.str()+" GeV"; hTT->SetTitle(temp.c_str()); hTT->Scale(LumiScale); hTT->Rebin(binWidth); hTT->SetFillColor(39); gStyle->SetOptStat(0); //if(btag==0) // hTT->GetYaxis()->SetRangeUser(0.0001,245); //if(btag==1) // hTT->GetYaxis()->SetRangeUser(0.0001,245); //if(btag==2) // hTT->GetYaxis()->SetRangeUser(0.0001,25); //hTT->Draw(); TH1F *hVV =(TH1F*)VVFile->Get(histoName[btag].c_str()); hVV->SetName("hVV"); hVV->Scale(LumiScale); hVV->Rebin(binWidth); hVV->SetFillColor(38); TH1F* hH400 = (TH1F*)H400File->Get(histoName[btag].c_str()); hH400->SetName("hH400"); hH400->Scale(LumiScale*timesX); cout << "SIGNAL NORMALIZATION: " << hH400->Integral() << endl; hH400->Rebin(binWidth); hH400->SetFillColor(kYellow);//kRed+3); temp = ";m_{ZZ} [GeV];Events / "+convert.str()+" GeV"; THStack *hBkg = new THStack("hBkg",temp.c_str()); convert.str(""); hBkg->Add(hVV); hBkg->Add(hTT); hBkg->Add(hZjets); hBkg->Add(hH400); float xMin = 150.; float xMax = 750.; float yMin = 0.; float yMax = 1.3*hBkg->GetMaximum(); char yAxisName[500]; sprintf( yAxisName, "Events / %.0f GeV", hVV->GetXaxis()->GetBinWidth(1) ); //std::string yAxisName = "Events / "+convert.str()+" GeV"; convert.str(""); //char xAxisName[400]; //sprintf( xAxisName, "m_{%s%sjj} [GeV]", leptType_forLegend.c_str(), leptType_forLegend.c_str() ); TH2D* h2_axes = new TH2D("axes", "", 10, xMin, xMax, 10, yMin, yMax); h2_axes->SetXTitle("m_{lljj} [GeV]"); h2_axes->SetYTitle(yAxisName); h2_axes->Draw(); hBkg->Draw("SAMEHIST"); plot_MCbkg->Draw("SAME"); cmslabel->Draw(); label_sqrt->Draw(); // ---------------legend --------------------------- TLegend *leg = new TLegend(.4,.5,.8,.9); leg->SetTextSize(0.036); leg->SetFillColor(0); leg->SetBorderSize(0); convert.str(""); convert << LumiScale/1000; temp="CMS Preliminary #sqrt{s}=7 TeV "+convert.str()+" fb^{-1}"; //leg->SetHeader(temp.c_str()); leg->AddEntry("background_Norm[mZZ]","Sideband Extrapolated Fit","l"); //leg->AddEntry("model_Norm[mZZ]","Background+10#timesSignal","l"); if(btag==0) temp="0 b-tag 2l2q data"; if(btag==1) temp="1 b-tag 2l2q data"; if(btag==2) temp="2 b-tag 2l2q data"; leg->AddEntry("h_data_bkg",temp.c_str(),"p"); leg->AddEntry("hZjets","Z + Jets","f"); leg->AddEntry("hTT","tt/tW","f"); leg->AddEntry("hVV","ZZ/WZ/WW","f"); convert.str(""); convert << timesX; temp="400 GeV SM Higgs#times"+convert.str(); leg->AddEntry("hH400",temp.c_str(),"f"); leg->Draw(); string saveFileName="AllInOne_"+dataset + "_"+btagName[btag]+"tag_ll_LIMIT" + useNewShapeText + ".eps"; c2->SaveAs(saveFileName.c_str()); }
void vs_PlotQCDcomp() { Bool_t saveC = false; Bool_t diJets = true; Bool_t isMC = false; TString vsSave; vsSave = "_T07w"; TString jSave; if(diJets) jSave = "2j"; else jSave = "3j"; TString sample; if(diJets) sample = "select_1ph_2jets"; else sample = "select_1ph_3jets"; TString FOtag; if(isMC) FOtag = "_FO_CorrMC"; // else FOtag = "_FO_Corr"; else FOtag = "_FO"; TString sysu = "SYSTUP_"; TString sysd = "SYSTDOWN_"; TString outDir; outDir = "Plots_PhotonSusyAnalysis/QCDweights/"; // string inputFile1 = "/data/user/vsola/CMSSW_Releases/CMSSW_5_3_9/src/Plots_PhotonSusyAnalysis/Merged_QCD_PhotonJet_T07w_PAT/mergedHistos.root"; // string inputFile1 = "/data/user/vsola/CMSSW_Releases/CMSSW_5_3_9/src/Plots_PhotonSusyAnalysis/Merged_Data_V05w_PAT/mergedHistos.root"; string inputFile1 = "/data/user/vsola/CMSSW_Releases/CMSSW_5_3_9/src/Plots_PhotonSusyAnalysis/PhotonHadReReco_22Jan2013_V05_PAT/mergedHistos.root"; setMyTDRStyle(); gROOT->SetStyle("mytdrStyle"); // gStyle->SetHistMinimumZero(); // gStyle->SetPaintTextFormat("4.2f"); gStyle->SetHistLineWidth(2); gStyle->UseCurrentStyle(); // gStyle->SetPadTopMargin(1.0); // gStyle->SetPadLeftMargin(3.2); // gStyle->SetPadRightMargin(4.5); // gStyle->SetPadBottomMargin(3.2); gROOT->ForceStyle(1); static const Int_t nHt = 7; static const Int_t nPt = 13; static const Int_t nMet = 16; static const Int_t nJet = 15; Double_t binPt[nPt+1] = {0.,75.,90.,120.,160.,210.,260.,320.,400.,500.,650.,800.,1000.,1500.}; Double_t binHt[nHt+1] = {0.,400.,450.,550.,700.,900.,1200.,1500.}; Double_t binMet[nMet+1] = {0.,10.,20.,30.,40.,50.,60.,70.,80.,90.,100.,120.,160.,200.,270.,350.,500.}; Double_t binJet[nJet+1] = {0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15}; TLatex *as = new TLatex(); as->SetNDC(true); as->SetTextColor(12); as->SetTextFont(43); as->SetTextSize(19); TLegend *legend = new TLegend(0.60, 0.70, 0.75, 0.85, ""); legend->SetFillColor(10); legend->SetFillStyle(1001); legend->SetTextSize(0.04); legend->SetBorderSize(0); legend->SetShadowColor(0); std::string outLumi = "CMS Work in Progress - QCD MC #sqrt{s} = 8 TeV - #geq 1 #gamma, #geq 2 j"; TFile* f1 = TFile::Open( inputFile1.c_str() ); //photon Pt TCanvas * cPt = new TCanvas("cPt","cPt"); TH1F* hpt = (TH1F*) f1->Get( sample+"/PreselCut_photonPt" ); TH1F* hptFO = (TH1F*) f1->Get( sample+FOtag+"/PreselCut_photonPt" ); TH1F *hptR = (TH1F*) hpt->Rebin(nPt,hpt->GetTitle(),binPt); if (hptR->GetSumw2N() == 0) hptR->Sumw2(); TH1F *hptFOR = (TH1F*) hptFO->Rebin(nPt,hptFO->GetTitle(),binPt); if (hptFOR->GetSumw2N() == 0) hptFOR->Sumw2(); TH1F* hptSU = (TH1F*) f1->Get( sample+FOtag+"/PreselCut_"+sysu+"photonPt" ); TH1F* hptSD = (TH1F*) f1->Get( sample+FOtag+"/PreselCut_"+sysd+"photonPt" ); TH1F *hptSUR = (TH1F*) hptSU->Rebin(nPt,hptSU->GetTitle(),binPt); if (hptSUR->GetSumw2N() == 0) hptSUR->Sumw2(); TH1F *hptSDR = (TH1F*) hptSD->Rebin(nPt,hptSD->GetTitle(),binPt); if (hptSDR->GetSumw2N() == 0) hptSDR->Sumw2(); if ( hptFOR != 0 ) { for (int b = 0; b < hptFOR->GetNbinsX(); b++) { Double_t mainHistoContent = hptFOR->GetBinContent(b); Double_t systUpHistoContent = hptSUR->GetBinContent(b); Double_t systDnHistoContent = hptSDR->GetBinContent(b); Double_t systDiffUp = fabs( (double) systUpHistoContent - mainHistoContent ); Double_t systDiffDn = fabs( (double) mainHistoContent - systDnHistoContent ); // use average error for histogram Double_t systDiff = ( systDiffUp + systDiffDn ) / 2.; Double_t statErr = hptFOR->GetBinError(b); Double_t combError = sqrt( systDiff * systDiff + statErr * statErr ); hptFOR->SetBinError(b, combError); } //for }//if cPt->SetLogy(1); gPad->Update(); cPt->Update(); // hptR->Scale(1,"width"); // hptR->SetMinimum(0.02); // hptR->SetMaximum(1000); hptR->GetXaxis()->SetTitle("1^{st} photon p_{T} [GeV]"); hptR->GetYaxis()->SetTitle("Number of Events / GeV"); if(isMC) hptR->SetMarkerSize(0); if(isMC) hptR->Draw("histE"); else hptR->Draw("E X0"); hptFOR->SetMarkerSize(0); hptFOR->SetLineColor(2); hptFOR->SetFillColor(2); hptFOR->SetFillStyle(3004); hptFOR->Draw("same hist ][ E2"); legend->Clear(); if(isMC) legend->SetHeader("#gamma/QCD (Sim)"); else legend->SetHeader("#gamma/QCD (Data)"); if(isMC) legend->AddEntry(hptR, "#gamma", "l"); else legend->AddEntry(hptR, "#gamma", "p"); legend->AddEntry(hptFOR, "Pred (from #gamma_{jet})", "f"); legend->Draw(); as->DrawLatex(0.17, 0.93, outLumi.c_str() ); cPt->Update(); cPt->SetBottomMargin(0.2 + 0.8 * cPt->GetBottomMargin() - 0.2 * cPt->GetTopMargin()); TPad *ratioPt = new TPad("BottomPad", "", 0, 0, 1, 1); ratioPt->SetTopMargin(0.8 - 0.8 * ratioPt->GetBottomMargin() + 0.2 * ratioPt->GetTopMargin()); ratioPt->SetFillStyle(0); ratioPt->SetFrameFillColor(10); ratioPt->SetFrameBorderMode(0); ratioPt->Draw(); ratioPt->cd(); ratioPt->SetLogy(0); TH1F *hptRat = (TH1F*) divideHistosForRatio(hptR,hptFOR); hptRat->SetMinimum(0.); hptRat->SetMaximum(10.); hptRat->GetXaxis()->SetNdivisions(505); if(isMC) hptRat->GetYaxis()->SetTitle("Sim/Pred"); else hptRat->GetYaxis()->SetTitle("Data/Pred"); hptRat->GetYaxis()->SetTitleSize(0.04); hptRat->GetYaxis()->SetLabelSize(0.03); hptRat->GetYaxis()->SetTitleOffset(1.3); hptRat->GetYaxis()->SetNdivisions(505); hptRat->SetMarkerStyle(20); hptRat->SetMarkerSize(1); hptRat->SetMarkerColor(1); hptRat->SetLineColor(1); hptRat->Draw("E X0"); TH1F *hptFRat = (TH1F*) getSystErrForRatio(hptFOR); hptFRat->SetLineColor(2); hptFRat->SetFillColor(2); hptFRat->SetFillStyle(3004); hptFRat->Draw("same hist ][ E2"); TLine * line = new TLine( hptRat->GetXaxis()->GetXmin(), 1., hptRat->GetXaxis()->GetXmax(), 1. ); line->SetLineColor(1); line->SetLineWidth(0.5); line->SetLineStyle(1); line->Draw("same"); hptR->GetXaxis()->SetLabelSize(0); hptR->GetXaxis()->SetTitle(""); cPt->RedrawAxis(); gPad->Update(); cPt->Update(); return; }
int main(int argc, char *argv[]) { // make sure command line arguments were supplied if (argc != 6) { cerr << "Usage: " << argv[0] << " [reference.root] [new-comparison.root] [root dir] [new-release] [old-release] \n"; return 1; } // create the comparison class PlotCompareUtility *pc = new PlotCompareUtility(argv[1],argv[2],argv[3],"METTask_"); HistoData *hd; if (pc->GetStatus() != 0) { cout << "Final Result: no_data" << endl; return 0; } // add histogram information //Type = 0 (Do not rebin or zoom) , 1 (Rebin and Zoom, x-axis > 0 ) , 2 (Rebin and Zoom) hd = pc->AddHistoData("MET"); hd->SetType(1); hd = pc->AddHistoData("METPhi"); hd->SetType(2); hd = pc->AddHistoData("METSig"); hd->SetType(1); hd = pc->AddHistoData("MEx"); hd->SetType(2); hd = pc->AddHistoData("MEy"); hd->SetType(2); hd = pc->AddHistoData("SumET"); hd->SetType(2); if (pc->GetStatus() != 0) { cerr << "error encountered, exiting.\n"; return pc->GetStatus(); } int num_histos = pc->GetNumHistos(); bool combinedFailed = false; float threshold = KS_TEST ? pc->GetKSThreshold() : pc->GetChi2Threshold(); // get the reference and comparison histograms int Nevents_ref = ((TH1F *)pc->GetRefHisto("Nevents"))->GetEntries(); int Nevents_new = ((TH1F *)pc->GetNewHisto("Nevents"))->GetEntries(); int Nevents = -1; if (Nevents_ref>Nevents_new) Nevents = Nevents_ref; else Nevents = Nevents_new; // create summary histograms TH1F h1dResults_passed("h1dResults_passed","",num_histos, 1, num_histos + 1); TH1F h1dResults_failed("h1dResults_failed","",num_histos, 1, num_histos + 1); // loop over the supplied list of histograms for comparison for (int index = 0; index < pc->GetNumHistos(); index++) { int number = index + 1; hd = pc->GetHistoData(number); //int type = hd->GetType(); //types[index] = type; string name = hd->GetName(); //string value = hd->GetValueX(); cout << name << endl; // get the reference and comparison histograms TH1F *href = (TH1F *)pc->GetRefHisto(name); TH1F *hnew = (TH1F *)pc->GetNewHisto(name); // ignore if histogram is empty if (hnew->GetEntries() <= 1 || href->GetEntries() <= 1) { cerr << name << " error: no entries"; combinedFailed = true; continue; } // calculate and set range and number of bins double h1RMS = hnew->GetRMS(); double h2RMS = href->GetRMS(); double RMS = TMath::Max(h1RMS, h2RMS); double h1Mean = hnew->GetMean(); double h2Mean = href->GetMean(); double Mean = 0.5 * (h1Mean + h2Mean); double Nbins = href->GetNbinsX(); double min = href->GetXaxis()->GetXmin(); double max = href->GetXaxis()->GetXmax(); double dX = max - min; double dNdX = 1; double NewMin = min; double NewMax = max; int rebinning = Nbins; if (RMS>0 && hd->GetType() ) { dNdX = 100. / ( 10 * RMS); NewMin = Mean - 10 * RMS; NewMax = Mean + 10 * RMS; } if ((dX * dNdX)>0 && hd->GetType() ) rebinning = (int)(double(Nbins) / (dX * dNdX)); if ( rebinning > 1 && hd->GetType() ) { href->Rebin(rebinning); hnew->Rebin(rebinning); } if ( hd->GetType() == 1 ) { href->GetXaxis()->SetRangeUser(0.0, NewMax); hnew->GetXaxis()->SetRangeUser(0.0, NewMax); } else if ( hd->GetType() == 2 ) { href->GetXaxis()->SetRangeUser(NewMin, NewMax); hnew->GetXaxis()->SetRangeUser(NewMin, NewMax); } // perform statistical tests double ks_score = hnew->KolmogorovTest(href,"D"); double chi2_score = hnew->Chi2Test(href, "p"); //double result = KS_TEST ? ks_score : chi2_score; double result = (ks_score>chi2_score) ? ks_score : chi2_score; href->SetNormFactor(Nevents_new); hnew->SetNormFactor(Nevents_new); //hnew->SetNormFactor(1); // ensure that the peaks of both histograms will be shown by making a dummy histogram float Nentries_ref = href->GetEntries(); float Nentries_new = hnew->GetEntries(); float XaxisMin_ref = 0, XaxisMax_ref = 0, YaxisMin_ref = 0, YaxisMax_ref = 0; float XaxisMin_new = 0, XaxisMax_new = 0, YaxisMin_new = 0, YaxisMax_new = 0; if (Nentries_ref>0) YaxisMax_ref = (href->GetMaximum()+TMath::Sqrt(href->GetMaximum()))*(Nentries_new/Nentries_ref); if (Nentries_new>0) YaxisMax_new = (hnew->GetMaximum()+TMath::Sqrt(hnew->GetMaximum())); XaxisMin_ref = href->GetXaxis()->GetXmin()>NewMin ? href->GetXaxis()->GetXmin() : NewMin; XaxisMax_ref = href->GetXaxis()->GetXmax()<=NewMax ? href->GetXaxis()->GetXmax() : NewMax; YaxisMax_ref = (YaxisMax_ref>=YaxisMax_new) ? YaxisMax_ref : YaxisMax_new; if (TMath::Abs(XaxisMin_ref - XaxisMax_ref)<1E-6) { XaxisMin_ref = 0; XaxisMax_ref = 1; } TH1F *hdumb = new TH1F("hdumb","", rebinning, XaxisMin_ref, XaxisMax_ref); hdumb->SetMinimum(1E-1); //--For Rick hdumb->SetMaximum(1.05*YaxisMax_ref); // if (href->GetMaximum() < hnew->GetMaximum()) // href->SetAxisRange(0, 1.1 * hnew->GetMaximum(), "Y"); // set drawing options on the reference histogram href->SetStats(0); href->SetLineWidth(2); href->SetLineColor(14); href->SetMarkerColor(14); href->SetFillColor(17); //href->SetFillStyle(3004); href->GetXaxis()->SetTitle(name.c_str()); href->GetYaxis()->SetTitle("Entries"); href->GetYaxis()->SetTitleOffset(1.5); // set drawing options on the new histogram hnew->SetStats(0); hnew->SetLineWidth(2); hnew->SetFillStyle(3001); // set drawing options on the dummy histogram hdumb->SetStats(0); hdumb->GetXaxis()->SetTitle(name.c_str()); hdumb->GetXaxis()->SetLabelSize(0.5 * hdumb->GetXaxis()->GetTitleSize()); hdumb->GetYaxis()->SetTitle("Entries"); hdumb->GetYaxis()->SetTitleOffset(1.5); hdumb->GetYaxis()->SetLabelSize(0.5 * hdumb->GetXaxis()->GetTitleSize()); stringstream ss_title; ss_title.precision(5); if (ks_score>chi2_score) ss_title << "KS Score = " << ks_score; else ss_title << "Chi^2 Score = " << chi2_score; TText canvas_title(0.1,0.97,ss_title.str().c_str()); // determine if test is a "pass" or a "fail" if (result <= threshold) { canvas_title.SetTextColor(kRed); // make this histogram red to denote failure hnew->SetFillColor(kRed); hnew->SetLineColor(206); hnew->SetMarkerColor(206); // mark the entire sample as being 'not-compatible' combinedFailed = true; // set the summary bin to failed (only need to set titles for passed h1dResults) h1dResults_passed.GetXaxis()->SetBinLabel(number, name.c_str()); h1dResults_failed.SetBinContent(number, result); } else { canvas_title.SetTextColor(kGreen); // make this histogram green to denote passing score hnew->SetFillColor(kGreen); hnew->SetLineColor(103); hnew->SetMarkerColor(103); // set the summary bin to passed h1dResults_passed.GetXaxis()->SetBinLabel(number, name.c_str()); h1dResults_passed.SetBinContent(number, result); } // setup canvas for displaying the compared histograms TCanvas histo_c("histo_c","histo_c",785,800); histo_c.Draw(); TPad histo_p("histo_p","histo_p",0,0,1,0.99); histo_p.Draw(); histo_c.cd(); canvas_title.SetTextSize(0.025); canvas_title.Draw(); histo_p.cd(); histo_p.SetLogy(1); //--This is just for Dr. Rick hdumb->Draw(); href->Draw("SAME"); hnew->Draw("SAME"); hnew->Draw("E1SAME"); stringstream legend_new; stringstream legend_ref; legend_new << argv[4] << ": " << Nentries_new << " entries, " << Nevents_new << " events"; legend_ref << argv[5] << ": " << Nentries_ref << " entries, " << Nevents_ref << " events"; TLegend l1(0.15,0.001,0.33, 0.06); l1.SetTextSize(0.02); l1.AddEntry(hnew, legend_new.str().c_str(),"lF"); l1.AddEntry(href, legend_ref.str().c_str(),"lF"); l1.SetFillColor(kNone); l1.Draw("SAME"); // print the result to gif string histo_name = name + ".gif"; histo_c.Print(histo_name.c_str(),"gif"); cout << "Result of comparison for " << name << ": ks score = " << ks_score << " : chi2 score = " << chi2_score << endl << endl; } // create summary canvas int summary_height = int(780 * float(num_histos) / 11); // 780; TCanvas main_c("main_c","main_c",799,summary_height); main_c.Draw(); TPad main_p("main_p","main_p",0.01,0.01,0.99,0.94); main_p.SetLeftMargin(0.30); main_p.SetBottomMargin(0.15); main_p.SetLogx(1); main_p.SetGrid(); main_p.SetFrameFillColor(10); main_p.Draw(); main_c.cd(); TText summary_title(.01, .95, ""); summary_title.Draw("SAME"); main_p.cd(); // setup the passing test bars h1dResults_passed.SetStats(0); h1dResults_passed.GetXaxis()->SetLabelSize(0.06); h1dResults_passed.GetYaxis()->SetLabelSize(0.04); h1dResults_passed.GetYaxis()->SetTitle("Compatibility"); h1dResults_passed.SetBarWidth(0.7); h1dResults_passed.SetBarOffset(0.1); h1dResults_passed.SetFillColor(kGreen); h1dResults_passed.SetLineColor(1); h1dResults_passed.GetYaxis()->SetRangeUser(1E-7,2); h1dResults_passed.Draw("hbar0"); // setup the failing test bars h1dResults_failed.SetStats(0); h1dResults_failed.GetXaxis()->SetLabelSize(0.06); h1dResults_failed.GetYaxis()->SetLabelSize(0.04); h1dResults_failed.GetYaxis()->SetTitle("Compatibility"); h1dResults_failed.SetBarWidth(0.7); h1dResults_failed.SetBarOffset(0.1); h1dResults_failed.SetFillColor(kRed); h1dResults_failed.SetLineColor(1); h1dResults_failed.GetYaxis()->SetRangeUser(1E-7,2); h1dResults_failed.Draw("hbar0SAME"); // draw the pass/fail threshold line TLine l(threshold, 1, threshold, num_histos+1); l.SetLineColor(kRed); l.SetLineWidth(2); l.SetLineStyle(2); l.Draw("SAME"); // print the results main_c.Update(); main_c.Print("AllResults-1dHistoCheck.gif","gif"); if (combinedFailed) cout << "Final Result: fail" << endl; else cout << "Final Result: pass" << endl; //delete pc; return 0; }
void controlPlots(){ gStyle->SetOptStat(0); std::vector<bool> *bvec = new std::vector<bool>; bvec->push_back(0); std::cout << bvec->size() << std::endl; // string dir="/shome/wehrlilu/SecVtx/SVProd/SVVALIDATION/forbatchjobs/temp/BBC/CMSSW_3_7_0_patch2/src/crab/analyze/rootoutput/tempPTplots2/"; string dir="/shome/wehrlilu/SecVtx/SVProd/SVVALIDATION/forbatchjobs/temp/BBC/CMSSW_3_7_0_patch2/crab/analyze/rootoutput/tempPTplotsALL/"; string dirMC="mc/"; string dirDATA="data/"; string strigger="jet30/"; //LUMI DATA FOR JET30: 0.313154 JET50U: 3.06903 ((IN /PB)) //MC LUMI IS 1/PB bool luminorm=0; double lumiDATA=0.313154; bool log=0; // bool twoBonly = true; // //pt hard reco (2V events) // string histoname = "Vert_ptrechard_2bVert"; // string axis = "harder vertex pt"; // int nbins = 100; double lower=0.0, upper = 200; // unsigned int rebinBy=2; //pt soft reco (2V events) string histoname = "Vert_ptrecsoft_2bVert"; string axis = "softer vertex pt"; int nbins = 100; double lower=0.0, upper = 200; unsigned int rebinBy=2; // //average pt reco (2V events) // string histoname = "Vert_ptrecaver_2bVert"; // string axis = "average vertex pt"; // int nbins = 100; double lower=0.0, upper = 200; // unsigned int rebinBy=2; // //asymmetry pt reco (2V events) // string histoname = "Vert_ptrecasym_2bVert"; // string axis = "asymmetry of vertex pt"; // int nbins = 50; double lower=0.0, upper = 1.0; // unsigned int rebinBy=2; // if(twoBonly) histoname = histoname + "_2b"; TFile *fMC1 = TFile::Open((dir+dirMC+"histos_qcdpt15_test_v2.root").c_str()); TFile *fMC2 = TFile::Open((dir+dirMC+"histos_qcdpt30_test_v2_125of127.root").c_str()); TFile *fMC3 = TFile::Open((dir+dirMC+"histos_qcdpt80_test_v3.root").c_str()); TFile *fMC4 = TFile::Open((dir+dirMC+"histos_qcdpt170_test_v1_79of80.root").c_str()); TFile *fDATA = TFile::Open((dir+dirDATA+"histo_allDATAupTo144114.root").c_str()); TH1F *hMC1; fMC1->GetObject((strigger+histoname).c_str(),hMC1); TH1F *hMC2; fMC2->GetObject((strigger+histoname).c_str(),hMC2); TH1F *hMC3; fMC3->GetObject((strigger+histoname).c_str(),hMC3); TH1F *hMC4; fMC4->GetObject((strigger+histoname).c_str(),hMC4); TH1F *hMCcombined= new TH1F("hMCcombined",axis.c_str(),nbins,lower,upper); TH1F *hDATA; fDATA->GetObject((strigger+histoname).c_str(),hDATA); TCanvas *c = new TCanvas("quant",axis.c_str(),100,300,500,500); hMC1->SetFillColor(0); hMC2->SetFillColor(0); hMC3->SetFillColor(0); hMC4->SetFillColor(0); hMCcombined->SetFillColor(0); hDATA->SetFillColor(0); hMC1->Scale(143.866); hMC2->Scale(12.1072); hMC3->Scale(0.310862); hMC4->Scale(0.0082391); hMCcombined->Add(hMC1); hMCcombined->Add(hMC2); hMCcombined->Add(hMC3); hMCcombined->Add(hMC4); //norm if(luminorm){ hMCcombined->Scale(lumiDATA); } else{ double intMC=hMCcombined->Integral(); double intDATA=hDATA->Integral(); hMCcombined->Scale(intDATA/intMC); } //numbers, cuts std::cout << "data lumi (/pb): " << lumiDATA << std::endl; std::cout << "trigger used: " << strigger << std::endl; std::cout << "Numbers\n"; std::cout << "MC:\t" << hMCcombined->Integral() << std::endl; std::cout << "DATA:\t" << hDATA->Integral() << std::endl; //rebin hMCcombined->Rebin(rebinBy); hDATA->Rebin(rebinBy); //format if(log) c->SetLogy(); double dmax = hMCcombined->GetMaximum(); if(dmax<hDATA->GetMaximum()) dmax = hDATA->GetMaximum(); if(log) hMCcombined->GetYaxis()->SetRangeUser(0.01,dmax*10.0); else hMCcombined->GetYaxis()->SetRangeUser(0.01,dmax+dmax/10.0); hMCcombined->GetXaxis()->SetTitle(axis.c_str()); hMCcombined->SetFillColor(8); hMCcombined->SetLineColor(8); hDATA->SetMarkerStyle(21); //draw hMCcombined->Draw("hist"); hDATA->Draw("samesPE"); //leg TLegend *leg = new TLegend(0.65,0.75,0.9,0.9); leg->SetFillColor(0); leg->AddEntry(hDATA,"Data","PE"); leg->AddEntry(hMCcombined,"Pythia","F"); leg->Draw(); }
void RAA_plot_JetID_CutEfficiency( Int_t radius = 4, char * etaWidth = (char*)"20_eta_p20"){ TH1::SetDefaultSumw2(); gStyle->SetOptStat(0); char * Coll = "PbPb"; //char * Coll = "Pp"; TDatime date; Int_t trigger[3]; if(Coll == "PbPb") {trigger[0] = 55; trigger[1] = 65; trigger[2] = 80;} if(Coll == "Pp") {trigger[0] = 40; trigger[1] = 60; trigger[2] = 80;} char * jetType; if(Coll == "PbPb") jetType = Form("akPu%dPF",radius); if(Coll == "Pp") jetType = Form("ak%dPF",radius); const int nbins_pt = 38; const double boundaries_pt[nbins_pt+1] = { 3, 4, 5, 7, 9, 12, 15, 18, 21, 24, 28, 32, 37, 43, 49, 56, 64, 74, 84, 97, 114, 133, 153, 174, 196, 220, 245, 300, 330, 362, 395, 430, 468, 507, 548, 592, 638, 686, 1000 }; // Pawan's files: TFile * fIn = TFile::Open(Form("/export/d00/scratch/rkunnawa/rootfiles/RAA/Pawan_ntuple_PbPb_data_MC_subid0_spectra_JetID_CutA_finebins_%s_R0p%d.root",etaWidth,radius)); TFile * fPP_in = TFile::Open(Form("/export/d00/scratch/rkunnawa/rootfiles/RAA/Pawan_ntuple_PP_data_MC_spectra_residualFactor_finebins_%s_R0p%d.root",etaWidth, radius)); // get the histograms, the Cut Efficiency is plotted from the MC histograms TH1F * hMC_noCut[3], * hMC_Cut[3], * hMC_unm_noCut[3], * hMC_unm_Cut[3]; TH1F * hMC_Denominator, *hMC_Numerator; for(int i = 0; i<3; i++){ hMC_noCut[i] = (TH1F*)fIn->Get(Form("hMC_Jet%d_noCut", trigger[i])); hMC_Cut[i] = (TH1F*)fIn->Get(Form("hMC_Jet%d_CutA", trigger[i])); hMC_unm_noCut[i] = (TH1F*)fIn->Get(Form("hMC_unmatched_Jet%d_noCut", trigger[i])); hMC_unm_Cut[i] = (TH1F*)fIn->Get(Form("hMC_unmatched_Jet%d_CutA", trigger[i])); } hMC_Denominator = (TH1F*)hMC_noCut[0]->Clone("hMC_Denominator"); hMC_Denominator->Add(hMC_noCut[1]); hMC_Denominator->Add(hMC_noCut[2]); hMC_Denominator->Add(hMC_unm_noCut[0]); hMC_Denominator->Add(hMC_unm_noCut[1]); hMC_Denominator->Add(hMC_unm_noCut[2]); hMC_Numerator = (TH1F*)hMC_Cut[0]->Clone("hMC_Numerator"); hMC_Numerator->Add(hMC_Cut[1]); hMC_Numerator->Add(hMC_Cut[2]); hMC_Numerator->Add(hMC_unm_Cut[0]); hMC_Numerator->Add(hMC_unm_Cut[1]); hMC_Numerator->Add(hMC_unm_Cut[2]); TH1F * hCutEff = (TH1F*)hMC_Numerator->Clone("hCutEff"); hCutEff->Divide(hMC_Denominator); hCutEff = (TH1F*)hCutEff->Rebin(nbins_pt, "hCutEff", boundaries_pt); divideBinWidth(hCutEff); // line at 1 TCanvas * cCutEff = new TCanvas("cCutEff","",800,600); hCutEff->SetXTitle(Form("%s Gen p_{T} (GeV/c)",jetType)); hCutEff->SetYTitle("Jet ID Cut Efficiency"); hCutEff->SetTitle(" "); hCutEff->SetAxisRange(40, 300, "X"); hCutEff->SetAxisRange(0.9, 1.05, "Y"); hCutEff->SetMarkerStyle(20); hCutEff->SetMarkerColor(kBlack); hCutEff->Draw(); putCMSPrel(); drawText("|#eta|<2, |vz|<15", 0.6, 0.31, 20); drawText(Form("%s",Coll), 0.6, 0.21, 20); cCutEff->SaveAs(Form("May20/%s_Combined_CutEfficiency_R0p%d_%s_%d.pdf",Coll,radius,etaWidth,date.GetDate()),"RECREATE"); // plot the curves for the different centrality classes. get the combined spectra and do the ratio const int nbins_cent = 6; TH1F * hMC_Denominator[nbins_cent]; TH1F * hMC_Numerator[nbins_cent]; TH1F * hData_Denominator[nbins_cent]; TH1F * hData_Numerator[nbins_cent]; TH1F * hCutEff[nbins_cent]; TH1F * hCutEff_Data[nbins_cent]; TH1F * hPP_MC_Denominator = (TH1F*)fIn_PP->Get("hpp_MC_Comb_noCut"); TH1F * hPP_MC_Numerator = (TH1F*)fIn_PP->Get(Form("hpp_JetComb_gen_R%d_%s",radius,etaWidth)); TH1F * hPP_Data_Denominator = (TH1F*)fIn_PP->Get("hpp_Data_Comb_noCut"); TH1F * hPP_Data_Numerator = (TH1F*)fIn_PP->Get(Form("hpp_HLTComb_R%d_%s",radius,etaWidth)); TH1F * hPP_CutEff = (TH1F*)hPP_MC_Numerator->Clone("hPP_CutEff"); hPP_CutEff->Divide(hPP_MC_Denominator); hPP_CutEff->Rebin(10); hPP_CutEff->Scale(1./10); TH1F * hPP_CutEff_Data = (TH1F*)hPP_Data_Numerator->Clone("hPP_CutEff_Data"); hPP_CutEff_Data->Divide(hPP_Data_Denominator); hPP_CutEff_Data->Rebin(10); hPP_CutEff_Data->Scale(1./10); TLine *line = new TLine(60,1,299,1); line->SetLineStyle(2); line->SetLineWidth(2); for(int i = 0; i<nbins_cent; ++i){ hMC_Denominator[i] = (TH1F*)fIn->Get(Form("hpbpb_MC_noCut_cent%d",i)); hMC_Numerator[i] = (TH1F*)fIn->Get(Form("hpbpb_gen_R%d_%s_cent%d",radius,etaWidth, i)); hData_Denominator[i] = (TH1F*)fIn->Get(Form("hpbpb_Data_Comb_noCut_cent%d",i)); hData_Numerator[i] = (TH1F*)fIn->Get(Form("hpbpb_HLTComb_R%d_%s_cent%d",radius,etaWidth,i)); hCutEff[i] = (TH1F*)hMC_Numerator[i]->Clone(Form("CutEff_cent%d",i)); hCutEff[i]->Divide(hMC_Denominator[i]); hCutEff[i]->Rebin(20); hCutEff[i]->Scale(1./20); hCutEff_Data[i] = (TH1F*)hData_Numerator[i]->Clone(Form("CutEff_Data_cent%d",i)); hCutEff_Data[i]->Divide(hData_Denominator[i]); hCutEff_Data[i]->Rebin(20); hCutEff_Data[i]->Scale(1./20); } TCanvas * cCutEff = new TCanvas("cCutEff","",800,600); makeMultiPanelCanvas(cCutEff,3,2,0.0,0.0,0.2,0.15,0.07); for(int i = 0; i<nbins_cent; ++i){ cCutEff->cd(nbins_cent-i); hCutEff[i]->SetXTitle(Form("akPu%dPF Gen p_{T} (GeV/c)", radius)); hCutEff[i]->SetYTitle("Jet ID Cut Efficiency"); hCutEff[i]->SetTitle(" "); hCutEff[i]->SetAxisRange(50, 299, "X"); hCutEff[i]->SetAxisRange(0.95, 1.05, "Y"); hCutEff[i]->SetMarkerStyle(20); hCutEff[i]->SetMarkerColor(kBlack); hCutEff[i]->Draw(); line->Draw(); } putCMSPrel(); drawText("|#eta|<2, |vz|<15", 0.6, 0.31, 20); drawText(Form("%s",Coll), 0.6, 0.21, 20); cCutEff->SaveAs(Form("May20/%s_Combined_CutEfficiency_centralityClass_R0p%d_%s_%d.pdf",Coll,radius,etaWidth,date.GetDate()),"RECREATE"); TCanvas * cCutEff_Data = new TCanvas("cCutEff_Data","",800,600); makeMultiPanelCanvas(cCutEff_Data,3,2,0.0,0.0,0.2,0.15,0.07); for(int i = 0; i<nbins_cent; ++i){ cCutEff_Data->cd(nbins_cent-i); hCutEff_Data[i]->SetXTitle(Form("akPu%dPF Data reco p_{T} (GeV/c)", radius)); hCutEff_Data[i]->SetYTitle("Jet ID Cut Efficiency"); hCutEff_Data[i]->SetTitle(" "); hCutEff_Data[i]->SetAxisRange(60, 299, "X"); hCutEff_Data[i]->SetAxisRange(0.2, 1.1, "Y"); hCutEff_Data[i]->SetMarkerStyle(20); hCutEff_Data[i]->SetMarkerColor(kBlack); hCutEff_Data[i]->Draw(); line->Draw(); } putCMSPrel(); drawText("|#eta|<2, |vz|<15", 0.6, 0.31, 20); drawText(Form("%s",Coll), 0.6, 0.21, 20); cCutEff_Data->SaveAs(Form("May20/%s_Combined_CutEfficiency_Data_centralityClass_R0p%d_%s_%d.pdf",Coll,radius,etaWidth,date.GetDate()),"RECREATE"); TCanvas * cPP_CutEff = new TCanvas("cPP_CutEff","",800,600); hPP_CutEff->SetXTitle(Form("ak%dPF Gen p_{T} (GeV/c)", radius)); hPP_CutEff->SetYTitle("Jet ID Cut Efficiency"); hPP_CutEff->SetTitle(" "); hPP_CutEff->SetAxisRange(60, 299, "X"); hPP_CutEff->SetAxisRange(0.8,1.1,"Y"); hPP_CutEff->SetMarkerStyle(20); hPP_CutEff->Draw(); cPP_CutEff->SaveAs(Form("May20/PP_Combined_CutEfficiency_R0p%d_%d.pdf",radius, date.GetDate())); TCanvas * cPP_CutEff_Data = new TCanvas("cPP_CutEff_Data","",800,600); hPP_CutEff_Data->SetXTitle(Form(" ak%dPF Data reco p_{T} (GeV/c)", radius)); hPP_CutEff_Data->SetYTitle("Jet ID Cut Efficiency"); hPP_CutEff_Data->SetTitle(" "); hPP_CutEff_Data->SetAxisRange(60, 299, "X"); hPP_CutEff_Data->SetAxisRange(0.8,1.1,"Y"); hPP_CutEff_Data->SetMarkerStyle(20); hPP_CutEff_Data->Draw(); cPP_CutEff_Data->SaveAs(Form("May20/PP_Combined_CutEfficiency_Data_R0p%d_%s_%d.pdf",radius,etaWidth, date.GetDate())); }
void PlotEff() { gROOT->ProcessLine(".L ./tdrstyle.C"); setTDRStyle(); TFile *f1 = TFile::Open("./histo_file_HToTauTau_13TeV_Fall13dr_PU20bx25.root"); TFile *f2 = TFile::Open("./histo_file_HToTauTau_13TeV_Fall13dr_PU40bx25.root"); TFile *f3 = TFile::Open("./histo_file_HToTauTau_8TeV_HighPt.root"); gStyle->SetOptStat(0000000); TH1F* hTauGenMatchPt_AfterLooseIso3H = (TH1F*)f1->Get("hTauGenMatchPt_AfterLooseIso3H"); hTauGenMatchPt_AfterLooseIso3H->Rebin(4); TH1F* hGenTauPt = (TH1F*)f1->Get("hTauGenMatchPt"); hGenTauPt->Rebin(4); TH1F* EffLooseIso3Hits_Pt =new TH1F("EffLooseIso3Hits_Pt","EffLooseIso3Hits_Pt",50,0,200); EffLooseIso3Hits_Pt->Divide(hTauGenMatchPt_AfterLooseIso3H,hGenTauPt, 1. , 1. , "B"); TH1F* hTauGenMatchEta_AfterLooseIso3H = (TH1F*)f1->Get("hTauGenMatchEta_AfterLooseIso3H"); hTauGenMatchEta_AfterLooseIso3H->Rebin(2); TH1F* hGenTauEta = (TH1F*)f1->Get("hTauGenMatchEta"); hGenTauEta->Rebin(2); TH1F* EffLooseIso3Hits_Eta =new TH1F("EffLooseIso3Hits_Eta","EffLooseIso3Hits_Eta",50,-3,3); EffLooseIso3Hits_Eta->Divide(hTauGenMatchEta_AfterLooseIso3H,hGenTauEta, 1. , 1. , "B"); TH1F* hTauGenMatchPhi_AfterLooseIso3H = (TH1F*)f1->Get("hTauGenMatchPhi_AfterLooseIso3H"); TH1F* hGenTauPhi = (TH1F*)f1->Get("hTauGenMatchPhi"); TH1F* EffLooseIso3Hits_Phi =new TH1F("EffLooseIso3Hits_Phi","EffLooseIso3Hits_Phi",100,-3,3); EffLooseIso3Hits_Phi->Divide(hTauGenMatchPhi_AfterLooseIso3H,hGenTauPhi, 1. , 1. , "B"); TH1F* hOfflinePV_AfterLooseIso3H = (TH1F*)f1->Get("hOfflinePV_AfterLooseIso3H"); TH1F* hOfflinePV = (TH1F*)f1->Get("hOfflinePV"); f1->cd(); TH1F* hOfflinePV = (TH1F*)hOfflinePV->Clone(); //hOfflinePV_AfterLooseIso3H->SetRange(0,70); //hOfflinePV->SetRangeUser(0,70); TH1F* EffLooseIso3Hits_NPV =new TH1F("EffLooseIso3Hits_NPV","EffLooseIso3Hits_NPV",100,0,100); EffLooseIso3Hits_NPV->Divide(hOfflinePV_AfterLooseIso3H, hOfflinePV, 1. , 1. , "B"); ////////////////////////////////////////////////////////////////////////////////////////////// TH1F* hTauGenMatchPt_AfterLooseIso3H_40 = (TH1F*)f2->Get("hTauGenMatchPt_AfterLooseIso3H"); hTauGenMatchPt_AfterLooseIso3H_40->Rebin(4); TH1F* hGenTauPt_40 = (TH1F*)f2->Get("hTauGenMatchPt"); hGenTauPt_40->Rebin(4); TH1F* EffLooseIso3Hits_Pt_40 =new TH1F("EffLooseIso3Hits_Pt_40","EffLooseIso3Hits_Pt_40",50,0,200); EffLooseIso3Hits_Pt_40->Divide(hTauGenMatchPt_AfterLooseIso3H_40,hGenTauPt_40, 1. , 1. , "B"); TH1F* hTauGenMatchEta_AfterLooseIso3H_40 = (TH1F*)f2->Get("hTauGenMatchEta_AfterLooseIso3H"); hTauGenMatchEta_AfterLooseIso3H_40->Rebin(2); TH1F* hGenTauEta_40 = (TH1F*)f2->Get("hTauGenMatchEta"); hGenTauEta_40->Rebin(2); TH1F* EffLooseIso3Hits_Eta_40 =new TH1F("EffLooseIso3Hits_Eta_40","EffLooseIso3Hits_Eta_40",50,-3,3); EffLooseIso3Hits_Eta_40->Divide(hTauGenMatchEta_AfterLooseIso3H_40,hGenTauEta_40, 1. , 1. , "B"); TH1F* hTauGenMatchPhi_AfterLooseIso3H_40 = (TH1F*)f2->Get("hTauGenMatchPhi_AfterLooseIso3H"); TH1F* hGenTauPhi_40 = (TH1F*)f2->Get("hTauGenMatchPhi"); TH1F* EffLooseIso3Hits_Phi_40 =new TH1F("EffLooseIso3Hits_Phi_40","EffLooseIso3Hits_Phi_40",100,-3,3); EffLooseIso3Hits_Phi_40->Divide(hTauGenMatchPhi_AfterLooseIso3H_40,hGenTauPhi_40, 1. , 1. , "B"); TH1F* hOfflinePV_AfterLooseIso3H_40 = (TH1F*)f2->Get("hOfflinePV_AfterLooseIso3H"); TH1F* hOfflinePV_40 = (TH1F*)f2->Get("hOfflinePV"); TH1F* EffLooseIso3Hits_NPV_40 =new TH1F("EffLooseIso3Hits_NPV","EffLooseIso3Hits_NPV",100,0,100); EffLooseIso3Hits_NPV_40->Divide(hOfflinePV_AfterLooseIso3H_40, hOfflinePV_40, 1. , 1. , "B"); /////////////////////////////8tev////////////////////////////// TH1F* hTauGenMatchPt_AfterLooseIso3H_8Tev = (TH1F*)f3->Get("hTauGenMatchPt_AfterLooseIso3H"); hTauGenMatchPt_AfterLooseIso3H_8Tev->Rebin(4); TH1F* hGenTauPt_8Tev = (TH1F*)f3->Get("hTauGenMatchPt"); hGenTauPt_8Tev->Rebin(4); TH1F* EffLooseIso3Hits_Pt_8Tev =new TH1F("EffLooseIso3Hits_Pt_8Tev","EffLooseIso3Hits_Pt_8Tev",50,0,200); EffLooseIso3Hits_Pt_8Tev->Divide(hTauGenMatchPt_AfterLooseIso3H_8Tev,hGenTauPt_8Tev, 1. , 1. , "B"); TH1F* hTauGenMatchEta_AfterLooseIso3H_8Tev = (TH1F*)f3->Get("hTauGenMatchEta_AfterLooseIso3H"); hTauGenMatchEta_AfterLooseIso3H_8Tev->Rebin(2); TH1F* hGenTauEta_8Tev = (TH1F*)f3->Get("hTauGenMatchEta"); hGenTauEta_8Tev->Rebin(2); TH1F* EffLooseIso3Hits_Eta_8Tev =new TH1F("EffLooseIso3Hits_Eta_8Tev","EffLooseIso3Hits_Eta_8Tev",50,-3,3); EffLooseIso3Hits_Eta_8Tev->Divide(hTauGenMatchEta_AfterLooseIso3H_8Tev,hGenTauEta_8Tev, 1. , 1. , "B"); TH1F* hTauGenMatchPhi_AfterLooseIso3H_8Tev = (TH1F*)f3->Get("hTauGenMatchPhi_AfterLooseIso3H"); TH1F* hGenTauPhi_8Tev = (TH1F*)f3->Get("hTauGenMatchPhi"); TH1F* EffLooseIso3Hits_Phi_8Tev =new TH1F("EffLooseIso3Hits_Phi_8Tev","EffLooseIso3Hits_Phi_8Tev",100,-3,3); EffLooseIso3Hits_Phi_8Tev->Divide(hTauGenMatchPhi_AfterLooseIso3H_8Tev,hGenTauPhi_8Tev, 1. , 1. , "B"); TH1F* hOfflinePV_AfterLooseIso3H_8Tev = (TH1F*)f3->Get("hOfflinePV_AfterLooseIso3H"); TH1F* hOfflinePV_8Tev = (TH1F*)f3->Get("hOfflinePV"); TH1F* EffLooseIso3Hits_NPV_8Tev =new TH1F("EffLooseIso3Hits_NPV_8Tev","EffLooseIso3Hits_NPV_8Tev",100,0,100); EffLooseIso3Hits_NPV_8Tev->Divide(hOfflinePV_AfterLooseIso3H_8Tev, hOfflinePV_8Tev, 1. , 1. , "B"); //////////////////////Draw Eff/////////////////////////////////// TCanvas *Eff_LooseIso3Hits = new TCanvas("Eff_LooseIso3Hits","Eff Loose Isolation 3Hits",1600,900); Eff_LooseIso3Hits->Divide(2,2); Eff_LooseIso3Hits->cd(1); gPad->SetGridy(); EffLooseIso3Hits_Pt_8Tev->GetXaxis()->SetTitle("gen. P_{T}^{#tau} [GeV]"); EffLooseIso3Hits_Pt_8Tev->GetYaxis()->SetTitle("Efficiency"); EffLooseIso3Hits_Pt_40->SetMarkerColor(kBlue); EffLooseIso3Hits_Pt->SetMarkerColor(kMagenta); EffLooseIso3Hits_Pt_40->SetLineColor(kBlue); EffLooseIso3Hits_Pt->SetLineColor(kMagenta); EffLooseIso3Hits_Pt_8Tev->Draw("HISTE"); EffLooseIso3Hits_Pt->Draw("HISTESAME"); EffLooseIso3Hits_Pt_40->Draw("HISTESAME"); EffLooseIso3Hits_Pt_8Tev->SetMinimum(0.3); EffLooseIso3Hits_Pt_8Tev->SetMaximum(0.9); Eff_LooseIso3Hits->cd(2); gPad->SetGridy(); EffLooseIso3Hits_Eta_40->SetMarkerColor(kBlue); EffLooseIso3Hits_Eta_40->SetLineColor(kBlue); EffLooseIso3Hits_Eta->SetMarkerColor(kMagenta); EffLooseIso3Hits_Eta->SetLineColor(kMagenta); EffLooseIso3Hits_Eta_8Tev->Draw("HISTE"); EffLooseIso3Hits_Eta_40->Draw("HISTESAME"); EffLooseIso3Hits_Eta->Draw("HISTESAME"); EffLooseIso3Hits_Eta_8Tev->GetXaxis()->SetTitle("gen. #eta_{#tau}"); EffLooseIso3Hits_Eta_8Tev->GetYaxis()->SetTitle("Efficiency"); EffLooseIso3Hits_Eta_8Tev->SetMinimum(0.3); EffLooseIso3Hits_Eta_8Tev->SetMaximum(0.9); Eff_LooseIso3Hits->cd(3); gPad->SetGridy(); EffLooseIso3Hits_Phi_40->SetMarkerColor(kBlue); EffLooseIso3Hits_Phi->SetMarkerColor(kMagenta); EffLooseIso3Hits_Phi_40->SetLineColor(kBlue); EffLooseIso3Hits_Phi->SetLineColor(kMagenta); EffLooseIso3Hits_Phi_8Tev->Draw("HISTE"); EffLooseIso3Hits_Phi_40->Draw("SAMEHISTE"); EffLooseIso3Hits_Phi->Draw("SAMEHISTE"); EffLooseIso3Hits_Phi_8Tev->GetXaxis()->SetTitle("gen. #phi_{#tau}"); EffLooseIso3Hits_Phi_8Tev->GetYaxis()->SetTitle("Efficiency"); EffLooseIso3Hits_Phi_8Tev->SetMinimum(0.3); EffLooseIso3Hits_Phi_8Tev->SetMaximum(0.9); Eff_LooseIso3Hits->cd(4); gPad->SetGridy(); EffLooseIso3Hits_NPV_40->SetMarkerColor(kBlue); EffLooseIso3Hits_NPV->SetMarkerColor(kMagenta); EffLooseIso3Hits_NPV_40->SetLineColor(kBlue); EffLooseIso3Hits_NPV->SetLineColor(kMagenta); EffLooseIso3Hits_NPV_8Tev->GetXaxis()->SetRange(0, 70); EffLooseIso3Hits_NPV_40->GetXaxis()->SetRange(0, 70); EffLooseIso3Hits_NPV->GetXaxis()->SetRange(0, 70); EffLooseIso3Hits_NPV_8Tev->Draw(); EffLooseIso3Hits_NPV_40->Draw("HISTESAME"); EffLooseIso3Hits_NPV->Draw("HISTESAME"); EffLooseIso3Hits_NPV_8Tev->GetXaxis()->SetTitle("N_{vtx}"); EffLooseIso3Hits_NPV_8Tev->GetYaxis()->SetTitle("Efficiency"); EffLooseIso3Hits_NPV_8Tev->SetMinimum(0.); EffLooseIso3Hits_NPV_8Tev->SetMaximum(0.9); TLegend* legend = new TLegend( 0.2, 0.75, 0.65, 0.9); legend->SetTextSize(0.047); legend->SetFillColor(0); legend->AddEntry(EffLooseIso3Hits_Phi_8Tev, "Summer12, 8 TeV"); legend->AddEntry(EffLooseIso3Hits_Phi, "Fall13, 13 TeV, PU20, bx25"); legend->AddEntry(EffLooseIso3Hits_Phi_40, "Fall13, 13 TeV, PU40, bx25"); Eff_LooseIso3Hits->cd(3); legend->Draw("same"); Eff_LooseIso3Hits->SaveAs("LooseIsoEff.pdf"); }
void aliceReferror() { cout<<endl; cout<<endl; gStyle->SetOptFit(0); //Fill ALice(7TeV,|y|<0.5) and CMS(2.76TeV,|y|<1) FONLL values cout<<"---- Fill ALice(7TeV,|y|<0.5) and CMS(2.76TeV,|y|<1) FONLL values"<<endl; TString infnameAlice="fonllInput/fo_Dzero_pp_7_y0p5_curve.dat"; TString infnameAnly="fonllInput/fo_Dzero_pp_2p76_y1_curve.dat"; ifstream getdataAlice(infnameAlice.Data()); ifstream getdataAnly(infnameAnly.Data()); TH1F* hptAlice = new TH1F("hptAlice","",fo_BIN_NUM,HMIN,HMAX); TH1F* hptAnly = new TH1F("hptAnly","",fo_BIN_NUM,HMIN,HMAX); TH1F* hminallAlice = new TH1F("hminallAlice","",fo_BIN_NUM,HMIN,HMAX); //TH1F* hminallAnly = new TH1F("hminallAnly","",fo_BIN_NUM,HMIN,HMAX); TH1F* hmaxallAlice = new TH1F("hmaxallAlice","",fo_BIN_NUM,HMIN,HMAX); //TH1F* hmaxallAnly = new TH1F("hmaxllAnly","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt11Alice = new TH1F("hpt11Alice","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt11Anly = new TH1F("hpt11Anly","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt55Alice = new TH1F("hpt55Alice","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt55Anly = new TH1F("hpt55Anly","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt22Alice = new TH1F("hpt22Alice","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt22Anly = new TH1F("hpt22Anly","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt21Alice = new TH1F("hpt21Alice","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt21Anly = new TH1F("hpt21Anly","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt12Alice = new TH1F("hpt12Alice","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt12Anly = new TH1F("hpt12Anly","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt15Alice = new TH1F("hpt15Alice","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt15Anly = new TH1F("hpt15Anly","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt51Alice = new TH1F("hpt51Alice","",fo_BIN_NUM,HMIN,HMAX); TH1F* hpt51Anly = new TH1F("hpt51Anly","",fo_BIN_NUM,HMIN,HMAX); Double_t a11_Alice[fo_BIN_NUM],a55_Alice[fo_BIN_NUM],a22_Alice[fo_BIN_NUM],a21_Alice[fo_BIN_NUM],a12_Alice[fo_BIN_NUM],a15_Alice[fo_BIN_NUM],a51_Alice[fo_BIN_NUM]; Double_t a11_Anly[fo_BIN_NUM],a55_Anly[fo_BIN_NUM],a22_Anly[fo_BIN_NUM],a21_Anly[fo_BIN_NUM],a12_Anly[fo_BIN_NUM],a15_Anly[fo_BIN_NUM],a51_Anly[fo_BIN_NUM]; Double_t min_all_Alice[fo_BIN_NUM],max_all_Alice[fo_BIN_NUM],min_sc_Alice[fo_BIN_NUM],max_sc_Alice[fo_BIN_NUM],min_mass_Alice[fo_BIN_NUM],max_mass_Alice[fo_BIN_NUM],min_pdf_Alice[fo_BIN_NUM],max_pdf_Alice[fo_BIN_NUM]; Double_t min_all_Anly[fo_BIN_NUM],max_all_Anly[fo_BIN_NUM],min_sc_Anly[fo_BIN_NUM],max_sc_Anly[fo_BIN_NUM],min_mass_Anly[fo_BIN_NUM],max_mass_Anly[fo_BIN_NUM],min_pdf_Anly[fo_BIN_NUM],max_pdf_Anly[fo_BIN_NUM]; Int_t i,j; Double_t tem=0.; Double_t pdfrac=0.557*1.e-6; for(i=0;i<fo_BIN_NUM;i++) { getdataAlice>>tem; getdataAlice>>a11_Alice[i]; getdataAlice>>min_all_Alice[i]; getdataAlice>>max_all_Alice[i]; getdataAlice>>min_sc_Alice[i]; getdataAlice>>max_sc_Alice[i]; getdataAlice>>min_mass_Alice[i]; getdataAlice>>max_mass_Alice[i]; getdataAlice>>min_pdf_Alice[i]; getdataAlice>>max_pdf_Alice[i]; getdataAlice>>a55_Alice[i]; getdataAlice>>a22_Alice[i]; getdataAlice>>a21_Alice[i]; getdataAlice>>a12_Alice[i]; getdataAlice>>a15_Alice[i]; getdataAlice>>a51_Alice[i]; } for(i=0;i<fo_BIN_NUM;i++) { getdataAnly>>tem; getdataAnly>>a11_Anly[i]; getdataAnly>>min_all_Anly[i]; getdataAnly>>max_all_Anly[i]; getdataAnly>>min_sc_Anly[i]; getdataAnly>>max_sc_Anly[i]; getdataAnly>>min_mass_Anly[i]; getdataAnly>>max_mass_Anly[i]; getdataAnly>>min_pdf_Anly[i]; getdataAnly>>max_pdf_Anly[i]; getdataAnly>>a55_Anly[i]; getdataAnly>>a22_Anly[i]; getdataAnly>>a21_Anly[i]; getdataAnly>>a12_Anly[i]; getdataAnly>>a15_Anly[i]; getdataAnly>>a51_Anly[i]; } for(i=0;i<fo_BIN_NUM;i++) { hptAlice->SetBinContent(i+1,a11_Alice[i]*pdfrac); hminallAlice->SetBinContent(i+1,min_all_Alice[i]*pdfrac); hmaxallAlice->SetBinContent(i+1,max_all_Alice[i]*pdfrac); hpt11Alice->SetBinContent(i+1,a11_Alice[i]*pdfrac); hpt55Alice->SetBinContent(i+1,a55_Alice[i]*pdfrac); hpt22Alice->SetBinContent(i+1,a22_Alice[i]*pdfrac); hpt21Alice->SetBinContent(i+1,a21_Alice[i]*pdfrac); hpt12Alice->SetBinContent(i+1,a12_Alice[i]*pdfrac); hpt15Alice->SetBinContent(i+1,a15_Alice[i]*pdfrac); hpt51Alice->SetBinContent(i+1,a51_Alice[i]*pdfrac); hptAnly->SetBinContent(i+1,a11_Anly[i]*pdfrac); hpt11Anly->SetBinContent(i+1,a11_Anly[i]*pdfrac); hpt55Anly->SetBinContent(i+1,a55_Anly[i]*pdfrac); hpt22Anly->SetBinContent(i+1,a22_Anly[i]*pdfrac); hpt21Anly->SetBinContent(i+1,a21_Anly[i]*pdfrac); hpt12Anly->SetBinContent(i+1,a12_Anly[i]*pdfrac); hpt15Anly->SetBinContent(i+1,a15_Anly[i]*pdfrac); hpt51Anly->SetBinContent(i+1,a51_Anly[i]*pdfrac); } //Calculate data weighted ptbin centers cout<<"---- Calculate data weighted ptbin centers"<<endl; Double_t da_bincenter[da_BIN_NUM]; Double_t summul=0,sum=0; for(i=0;i<da_BIN_NUM;i++) { summul=0; sum=0; for(j=da_ptbin[i]*4;j<da_ptbin[i+1]*4;j++) { summul+=hptAlice->GetBinContent(j+1)*hptAlice->GetBinCenter(j+1); sum+=hptAlice->GetBinContent(j+1); } da_bincenter[i] = summul/sum; } //Back up TH1F* hptAliceRef=(TH1F*)hptAlice->Clone(); hptAliceRef->SetName("hptAliceRef"); TH1F* hptAnlyRef=(TH1F*)hptAnly->Clone(); hptAnlyRef->SetName("hptAnlyRef"); Double_t apt[da_BIN_NUM],aptl[da_BIN_NUM],aptlsyst[da_BIN_NUM],aptlscaling[da_BIN_NUM]; TH1F* hptAlice_rebinalice = (TH1F*)hptAliceRef->Rebin(da_BIN_NUM,"hptAlice_rebinalice",da_ptbin); for(i=0;i<da_BIN_NUM;i++) { apt[i] = hptAlice_rebinalice->GetBinCenter(i+1); aptl[i] = hptAlice_rebinalice->GetBinWidth(i+1)/2.; aptlsyst[i] = 1./6.; aptlscaling[i] = 1./4.; } //Test ALICE results if(testAliceData) { cout<<"---- Test Alice data points"<<endl; Double_t asigma[da_BIN_NUM],aerrorl[da_BIN_NUM],aerrorh[da_BIN_NUM],aminall[da_BIN_NUM],amaxall[da_BIN_NUM]; TH1F* hminallAlice_rebinalice = (TH1F*)hminallAlice->Rebin(da_BIN_NUM,"hminallAlice_rebinalice",da_ptbin); TH1F* hmaxallAlice_rebinalice = (TH1F*)hmaxallAlice->Rebin(da_BIN_NUM,"hmaxallAlice_rebinalice",da_ptbin); for(i=0;i<da_BIN_NUM;i++) { hptAlice_rebinalice->SetBinContent(i+1,hptAlice_rebinalice->GetBinContent(i+1)/(hptAlice_rebinalice->GetBinWidth(i+1)*4)); asigma[i]=hptAlice_rebinalice->GetBinContent(i+1); hminallAlice_rebinalice->SetBinContent(i+1,hminallAlice_rebinalice->GetBinContent(i+1)/(hminallAlice_rebinalice->GetBinWidth(i+1)*4)); aminall[i]=hminallAlice_rebinalice->GetBinContent(i+1); hmaxallAlice_rebinalice->SetBinContent(i+1,hmaxallAlice_rebinalice->GetBinContent(i+1)/(hmaxallAlice_rebinalice->GetBinWidth(i+1)*4)); amaxall[i]=hmaxallAlice_rebinalice->GetBinContent(i+1); aerrorl[i] = asigma[i]-aminall[i]; aerrorh[i] = amaxall[i]-asigma[i]; } TCanvas* cReproduceAlice = new TCanvas("cReproduceAlice","",600,600); cReproduceAlice->SetLogy(); TH2F* hempty_cReproduceAlice = new TH2F("hempty_cReproduceAlice","",10,0,25.,10.,0.006,1.e+3); hempty_cReproduceAlice->SetStats(0); hempty_cReproduceAlice->GetXaxis()->SetTitle("p_{t} (GeV/c)"); hempty_cReproduceAlice->GetYaxis()->SetTitle("d#sigma(D^{0})/dp_{T}(pb GeV-1c)"); hempty_cReproduceAlice->GetXaxis()->SetTitleOffset(1.); hempty_cReproduceAlice->GetYaxis()->SetTitleOffset(.9); hempty_cReproduceAlice->GetXaxis()->SetTitleSize(0.045); hempty_cReproduceAlice->GetYaxis()->SetTitleSize(0.045); hempty_cReproduceAlice->GetXaxis()->SetTitleFont(42); hempty_cReproduceAlice->GetYaxis()->SetTitleFont(42); hempty_cReproduceAlice->GetXaxis()->SetLabelFont(42); hempty_cReproduceAlice->GetYaxis()->SetLabelFont(42); hempty_cReproduceAlice->GetXaxis()->SetLabelSize(0.04); hempty_cReproduceAlice->GetYaxis()->SetLabelSize(0.04); hempty_cReproduceAlice->Draw(); TGraphAsymmErrors* gAliceFONLL = new TGraphAsymmErrors(da_BIN_NUM, apt, asigma, aptl, aptl, aerrorl, aerrorh); gAliceFONLL->SetFillColor(kRed); gAliceFONLL->SetFillStyle(3002); gAliceFONLL->SetLineWidth(2.); gAliceFONLL->SetLineColor(kRed); gAliceFONLL->Draw("5same"); TGraphAsymmErrors* gAliceSyst = new TGraphAsymmErrors(da_BIN_NUM, apt, da_cs, aptlsyst, aptlsyst, da_syst_dw, da_syst_up); gAliceSyst->SetFillColor(0); gAliceSyst->SetFillStyle(0); gAliceSyst->SetLineWidth(2.); gAliceSyst->SetLineColor(kBlack); gAliceSyst->Draw("5same"); TGraphAsymmErrors* gAliceStat = new TGraphAsymmErrors(da_BIN_NUM, apt, da_cs, aptl, aptl, da_stat, da_stat); gAliceStat->SetMarkerStyle(21); gAliceStat->SetMarkerColor(kBlack); gAliceStat->SetLineWidth(2); gAliceStat->SetLineColor(kBlack); gAliceStat->Draw("psame"); cReproduceAlice->SaveAs(Form("plots/%s/reproduceAlice.pdf",rapi.Data())); } cout<<"---- Rebin into data ptbins"<<endl; TH1F* hpt11Alice_rebin = (TH1F*)hpt11Alice->Rebin(da_BIN_NUM,"hpt11Alice_rebin",da_ptbin); TH1F* hpt55Alice_rebin = (TH1F*)hpt55Alice->Rebin(da_BIN_NUM,"hpt55Alice_rebin",da_ptbin); TH1F* hpt22Alice_rebin = (TH1F*)hpt22Alice->Rebin(da_BIN_NUM,"hpt22Alice_rebin",da_ptbin); TH1F* hpt21Alice_rebin = (TH1F*)hpt21Alice->Rebin(da_BIN_NUM,"hpt21Alice_rebin",da_ptbin); TH1F* hpt12Alice_rebin = (TH1F*)hpt12Alice->Rebin(da_BIN_NUM,"hpt12Alice_rebin",da_ptbin); TH1F* hpt15Alice_rebin = (TH1F*)hpt15Alice->Rebin(da_BIN_NUM,"hpt15Alice_rebin",da_ptbin); TH1F* hpt51Alice_rebin = (TH1F*)hpt51Alice->Rebin(da_BIN_NUM,"hpt51Alice_rebin",da_ptbin); TH1F* hpt11Anly_rebin = (TH1F*)hpt11Anly->Rebin(da_BIN_NUM,"hpt11Anly_rebin",da_ptbin); TH1F* hpt55Anly_rebin = (TH1F*)hpt55Anly->Rebin(da_BIN_NUM,"hpt55Anly_rebin",da_ptbin); TH1F* hpt22Anly_rebin = (TH1F*)hpt22Anly->Rebin(da_BIN_NUM,"hpt22Anly_rebin",da_ptbin); TH1F* hpt21Anly_rebin = (TH1F*)hpt21Anly->Rebin(da_BIN_NUM,"hpt21Anly_rebin",da_ptbin); TH1F* hpt12Anly_rebin = (TH1F*)hpt12Anly->Rebin(da_BIN_NUM,"hpt12Anly_rebin",da_ptbin); TH1F* hpt15Anly_rebin = (TH1F*)hpt15Anly->Rebin(da_BIN_NUM,"hpt15Anly_rebin",da_ptbin); TH1F* hpt51Anly_rebin = (TH1F*)hpt51Anly->Rebin(da_BIN_NUM,"hpt51Anly_rebin",da_ptbin); //Calculate ratios and errors with different sets of scaling cout<<"---- Calculate ratios and errors with different sets of scaling"<<endl; TH1F* hratio11_rebin = (TH1F*)hpt11Anly_rebin->Clone(); hratio11_rebin->SetName("hratio11_rebin"); hratio11_rebin->Divide(hpt11Alice_rebin); Double_t aratio11[da_BIN_NUM]; TH1F* hratio55_rebin = (TH1F*)hpt55Anly_rebin->Clone(); hratio55_rebin->SetName("hratio55_rebin"); hratio55_rebin->Divide(hpt55Alice_rebin); Double_t aratio55[da_BIN_NUM]; TH1F* hratio22_rebin = (TH1F*)hpt22Anly_rebin->Clone(); hratio22_rebin->SetName("hratio22_rebin"); hratio22_rebin->Divide(hpt22Alice_rebin); Double_t aratio22[da_BIN_NUM]; TH1F* hratio21_rebin = (TH1F*)hpt21Anly_rebin->Clone(); hratio21_rebin->SetName("hratio21_rebin"); hratio21_rebin->Divide(hpt21Alice_rebin); Double_t aratio21[da_BIN_NUM]; TH1F* hratio12_rebin = (TH1F*)hpt12Anly_rebin->Clone(); hratio12_rebin->SetName("hratio12_rebin"); hratio12_rebin->Divide(hpt12Alice_rebin); Double_t aratio12[da_BIN_NUM]; TH1F* hratio15_rebin = (TH1F*)hpt15Anly_rebin->Clone(); hratio15_rebin->SetName("hratio15_rebin"); hratio15_rebin->Divide(hpt15Alice_rebin); Double_t aratio15[da_BIN_NUM]; TH1F* hratio51_rebin = (TH1F*)hpt51Anly_rebin->Clone(); hratio51_rebin->SetName("hratio51_rebin"); hratio51_rebin->Divide(hpt51Alice_rebin); Double_t aratio51[da_BIN_NUM]; Double_t aratioErrup[da_BIN_NUM], aratioErrdw[da_BIN_NUM]; for(i=0;i<da_BIN_NUM;i++) { Double_t sortup=-1,sortdw=10000; aratio11[i] = hratio11_rebin->GetBinContent(i+1); if(aratio11[i]>sortup){sortup=aratio11[i];} if(aratio11[i]<sortdw){sortdw=aratio11[i];} aratio55[i] = hratio55_rebin->GetBinContent(i+1); if(aratio55[i]>sortup){sortup=aratio55[i];} if(aratio55[i]<sortdw){sortdw=aratio55[i];} aratio22[i] = hratio22_rebin->GetBinContent(i+1); if(aratio22[i]>sortup){sortup=aratio22[i];} if(aratio22[i]<sortdw){sortdw=aratio22[i];} aratio21[i] = hratio21_rebin->GetBinContent(i+1); if(aratio21[i]>sortup){sortup=aratio21[i];} if(aratio21[i]<sortdw){sortdw=aratio21[i];} aratio12[i] = hratio12_rebin->GetBinContent(i+1); if(aratio12[i]>sortup){sortup=aratio12[i];} if(aratio12[i]<sortdw){sortdw=aratio12[i];} aratio15[i] = hratio15_rebin->GetBinContent(i+1); if(aratio15[i]>sortup){sortup=aratio15[i];} if(aratio15[i]<sortdw){sortdw=aratio15[i];} aratio51[i] = hratio51_rebin->GetBinContent(i+1); if(aratio51[i]>sortup){sortup=aratio51[i];} if(aratio51[i]<sortdw){sortdw=aratio51[i];} aratioErrup[i] = sortup-aratio11[i]; aratioErrdw[i] = aratio11[i]-sortdw; } TGraph* gratio11 = new TGraph(da_BIN_NUM,da_ptctr,aratio11); TGraph* gratio55 = new TGraph(da_BIN_NUM,da_ptctr,aratio55); TGraph* gratio22 = new TGraph(da_BIN_NUM,da_ptctr,aratio22); TGraph* gratio21 = new TGraph(da_BIN_NUM,da_ptctr,aratio21); TGraph* gratio12 = new TGraph(da_BIN_NUM,da_ptctr,aratio12); TGraph* gratio15 = new TGraph(da_BIN_NUM,da_ptctr,aratio15); TGraph* gratio51 = new TGraph(da_BIN_NUM,da_ptctr,aratio51); cout<<" -- Plot FONLL ratio center values"<<endl; TCanvas* ccenterRatio = new TCanvas("ccenterRatio","",700,500); TH2F* hempty_ccenterRatio = new TH2F("hempty_ccenterRatio","",10,0,17.,10.,0.2,2.2); hempty_ccenterRatio->SetStats(0); hempty_ccenterRatio->GetXaxis()->SetTitle("p_{T} (GeV/c)"); hempty_ccenterRatio->GetYaxis()->SetTitle("#sigma(2.76TeV,|y|<1)/#sigma(7TeV.|y|<0.5)"); hempty_ccenterRatio->GetXaxis()->SetTitleOffset(1.); hempty_ccenterRatio->GetYaxis()->SetTitleOffset(.9); hempty_ccenterRatio->GetXaxis()->SetTitleSize(0.045); hempty_ccenterRatio->GetYaxis()->SetTitleSize(0.045); hempty_ccenterRatio->GetXaxis()->SetTitleFont(42); hempty_ccenterRatio->GetYaxis()->SetTitleFont(42); hempty_ccenterRatio->GetXaxis()->SetLabelFont(42); hempty_ccenterRatio->GetYaxis()->SetLabelFont(42); hempty_ccenterRatio->GetXaxis()->SetLabelSize(0.04); hempty_ccenterRatio->GetYaxis()->SetLabelSize(0.04); hempty_ccenterRatio->Draw(); gratio11->SetLineColor(1); gratio11->SetLineWidth(2); gratio11->Draw("lsame"); ccenterRatio->SaveAs(Form("plots/%s/cratioCenter.pdf",rapi.Data())); cout<<" -- Plot FONLL ratios with different sets of scaling"<<endl; TCanvas* ccompareRatio = new TCanvas("ccompareRatio","",700,500); TH2F* hempty_ccompareRatio = new TH2F("hempty_ccompareRatio","",10,0,17.,10.,0.2,2.2); hempty_ccompareRatio->SetStats(0); hempty_ccompareRatio->GetXaxis()->SetTitle("p_{T} (GeV/c)"); hempty_ccompareRatio->GetYaxis()->SetTitle("#sigma(2.76TeV,|y|<1)/#sigma(7TeV.|y|<0.5)"); hempty_ccompareRatio->GetXaxis()->SetTitleOffset(1.); hempty_ccompareRatio->GetYaxis()->SetTitleOffset(.9); hempty_ccompareRatio->GetXaxis()->SetTitleSize(0.045); hempty_ccompareRatio->GetYaxis()->SetTitleSize(0.045); hempty_ccompareRatio->GetXaxis()->SetTitleFont(42); hempty_ccompareRatio->GetYaxis()->SetTitleFont(42); hempty_ccompareRatio->GetXaxis()->SetLabelFont(42); hempty_ccompareRatio->GetYaxis()->SetLabelFont(42); hempty_ccompareRatio->GetXaxis()->SetLabelSize(0.04); hempty_ccompareRatio->GetYaxis()->SetLabelSize(0.04); hempty_ccompareRatio->Draw(); TGraphAsymmErrors* gratioGlobal = new TGraphAsymmErrors(da_BIN_NUM, apt, aratio11, aptl, aptl, aratioErrdw, aratioErrup); gratioGlobal->SetFillStyle(1001); gratioGlobal->SetFillColor(kYellow-9); gratioGlobal->Draw("2same"); gratio11->SetLineColor(1); gratio11->SetLineWidth(2); gratio11->Draw("lsame"); gratio55->SetLineColor(3); gratio55->SetLineWidth(2); gratio55->Draw("lsame"); gratio22->SetLineColor(9); gratio22->SetLineWidth(2); gratio22->Draw("lsame"); gratio21->SetLineColor(47); gratio21->SetLineWidth(2); gratio21->Draw("lsame"); gratio12->SetLineColor(6); gratio12->SetLineWidth(2); gratio12->Draw("lsame"); gratio15->SetLineColor(7); gratio15->SetLineWidth(2); gratio15->Draw("lsame"); gratio51->SetLineColor(43); gratio51->SetLineWidth(2); gratio51->Draw("lsame"); TLegend* legratioScaling = new TLegend(0.60,0.50,0.80,0.89); legratioScaling->SetFillColor(0); legratioScaling->SetBorderSize(0); legratioScaling->AddEntry((TObject*)0,"#mu_{F}/#mu_{0} #mu_{R}/#mu_{0}",""); legratioScaling->AddEntry(gratio11," 1 1","l"); legratioScaling->AddEntry(gratio55," 0.5 0.5","l"); legratioScaling->AddEntry(gratio22," 2 2","l"); legratioScaling->AddEntry(gratio21," 2 1","l"); legratioScaling->AddEntry(gratio12," 1 2","l"); legratioScaling->AddEntry(gratio15," 1 0.5","l"); legratioScaling->AddEntry(gratio51," 0.5 1","l"); legratioScaling->Draw("same"); ccompareRatio->SaveAs(Form("plots/%s/cratioGlobal.pdf",rapi.Data())); //Plot global relative FONLL ratio errors cout<<" -- Plot global relative FONLL ratio errors"<<endl; Double_t aratioRela[da_BIN_NUM],aratioErrdwRela[da_BIN_NUM],aratioErrupRela[da_BIN_NUM]; for(i=0;i<da_BIN_NUM;i++) { aratioRela[i] = 0; aratioErrdwRela[i] = aratioErrdw[i]/aratio11[i]; aratioErrupRela[i] = aratioErrup[i]/aratio11[i]; } TCanvas* cratioRela = new TCanvas("cratioRela","",700,500); cratioRela->SetGrid(); TH2F* hempty_cratioRela = new TH2F("hempty_cratioRela","",10,1,16.,10.,-1,1); hempty_cratioRela->SetStats(0); hempty_cratioRela->GetXaxis()->SetTitle("p_{T} (GeV/c)"); hempty_cratioRela->GetYaxis()->SetTitle("#sigma(2.76TeV,|y|<1.)/#sigma(7TeV,|y|<0.5) Relative unc."); hempty_cratioRela->GetXaxis()->SetTitleOffset(1.); hempty_cratioRela->GetYaxis()->SetTitleOffset(.9); hempty_cratioRela->GetXaxis()->SetTitleSize(0.045); hempty_cratioRela->GetYaxis()->SetTitleSize(0.045); hempty_cratioRela->GetXaxis()->SetTitleFont(42); hempty_cratioRela->GetYaxis()->SetTitleFont(42); hempty_cratioRela->GetXaxis()->SetLabelFont(42); hempty_cratioRela->GetYaxis()->SetLabelFont(42); hempty_cratioRela->GetXaxis()->SetLabelSize(0.04); hempty_cratioRela->GetYaxis()->SetLabelSize(0.04); hempty_cratioRela->Draw(); TGraphAsymmErrors* gratioRela = new TGraphAsymmErrors(da_BIN_NUM, apt, aratioRela, aptl, aptl, aratioErrdwRela, aratioErrupRela); gratioRela->SetFillStyle(3001); gratioRela->SetFillColor(8); gratioRela->Draw("2same"); cratioRela->SaveAs(Form("plots/%s/cratioRela.pdf",rapi.Data())); //Scale ALICE data points and propagate uncertainties cout<<"---- Scale ALice data center values and propagate uncertainties"<<endl; Double_t acrosssec[da_BIN_NUM],aminErr[da_BIN_NUM],amaxErr[da_BIN_NUM],aminErrrel[da_BIN_NUM],amaxErrrel[da_BIN_NUM],aminErrsyst[da_BIN_NUM],amaxErrsyst[da_BIN_NUM],aminErrstat[da_BIN_NUM],amaxErrstat[da_BIN_NUM],aminErrscaling[da_BIN_NUM],amaxErrscaling[da_BIN_NUM]; for(i=0;i<da_BIN_NUM;i++) { acrosssec[i] = da_cs[i]*aratio11[i]; aminErr[i] = acrosssec[i]*TMath::Sqrt((da_syst_dw[i]*da_syst_dw[i]+da_stat[i]*da_stat[i])/(da_cs[i]*da_cs[i]) + aratioErrdwRela[i]*aratioErrdwRela[i]); aminErrrel[i] = aminErr[i]/acrosssec[i]; amaxErr[i] = acrosssec[i]*TMath::Sqrt((da_syst_up[i]*da_syst_up[i]+da_stat[i]*da_stat[i])/(da_cs[i]*da_cs[i]) + aratioErrupRela[i]*aratioErrupRela[i]); amaxErrrel[i] = amaxErr[i]/acrosssec[i]; aminErrsyst[i] = acrosssec[i]*(da_syst_dw[i]/da_cs[i]); amaxErrsyst[i] = acrosssec[i]*(da_syst_up[i]/da_cs[i]); aminErrstat[i] = acrosssec[i]*(da_stat[i]/da_cs[i]); amaxErrstat[i] = acrosssec[i]*(da_stat[i]/da_cs[i]); aminErrscaling[i] = acrosssec[i]*aratioErrdwRela[i]; amaxErrscaling[i] = acrosssec[i]*aratioErrupRela[i]; } cout<<"---- Plot scaled data with different components of uncertainties"<<endl; TCanvas* cErrors = new TCanvas("cErrors","",500,500); cErrors->SetLogy(); TH2F* hempty_cErrors = new TH2F("hempty_cErrors","",10,0,17.,10.,1.e-2,1.e+3); hempty_cErrors->SetStats(0); hempty_cErrors->GetXaxis()->SetTitle("p_{t} (GeV/c)"); hempty_cErrors->GetYaxis()->SetTitle("d#sigma(D^{0})/dp_{T}(#mub GeV-1c)"); hempty_cErrors->GetXaxis()->SetTitleOffset(1.); hempty_cErrors->GetYaxis()->SetTitleOffset(.9); hempty_cErrors->GetXaxis()->SetTitleSize(0.045); hempty_cErrors->GetYaxis()->SetTitleSize(0.045); hempty_cErrors->GetXaxis()->SetTitleFont(42); hempty_cErrors->GetYaxis()->SetTitleFont(42); hempty_cErrors->GetXaxis()->SetLabelFont(42); hempty_cErrors->GetYaxis()->SetLabelFont(42); hempty_cErrors->GetXaxis()->SetLabelSize(0.04); hempty_cErrors->GetYaxis()->SetLabelSize(0.04); hempty_cErrors->Draw(); for(i=0;i<da_BIN_NUM;i++) { aptlscaling[i] = 1./3.; } TGraphAsymmErrors* gErrScaling = new TGraphAsymmErrors(da_BIN_NUM, da_ptctr, acrosssec, aptlscaling, aptlscaling, aminErrscaling, amaxErrscaling); gErrScaling->SetName("gErrScaling"); gErrScaling->SetLineWidth(0); gErrScaling->SetFillStyle(1001); gErrScaling->SetFillColor(kMagenta-7); gErrScaling->Draw("2same"); TGraphAsymmErrors* gErrTotal = new TGraphAsymmErrors(da_BIN_NUM, da_ptctr, acrosssec, aptl, aptl, aminErr, amaxErr); gErrTotal->SetFillStyle(0); gErrTotal->SetLineColor(kMagenta+2); gErrTotal->SetLineWidth(2); gErrTotal->Draw("5same"); TGraphAsymmErrors* gErrSyst = new TGraphAsymmErrors(da_BIN_NUM, da_ptctr, acrosssec, aptlsyst, aptlsyst, aminErrsyst, amaxErrsyst); gErrSyst->SetFillStyle(0); gErrSyst->SetLineColor(kAzure-2); gErrSyst->SetLineWidth(2.); gErrSyst->Draw("5same"); TGraphAsymmErrors* gErrStat = new TGraphAsymmErrors(da_BIN_NUM, da_ptctr, acrosssec, aptl, aptl, aminErrstat, amaxErrstat); gErrStat->SetMarkerSize(0); gErrStat->SetLineColor(kAzure-2); gErrStat->SetLineWidth(2.); gErrStat->Draw("psame"); TGraph* gErr = new TGraph(da_BIN_NUM, da_ptctr, acrosssec); gErr->SetMarkerStyle(20); gErr->SetMarkerSize(1.); gErr->SetMarkerColor(kMagenta+2); gErr->Draw("psame"); TLegend* legErrors = new TLegend(0.60,0.70,0.90,0.90); legErrors->SetFillColor(0); legErrors->SetBorderSize(0); legErrors->AddEntry(gErrTotal,"Total unc.","f"); legErrors->AddEntry(gErrSyst,"Data syst. unc.","f"); legErrors->AddEntry(gErrStat,"Data stat. unc.","lep"); legErrors->AddEntry(gErrScaling,"FONLL scaling unc.","f"); legErrors->Draw("same"); cErrors->SaveAs(Form("plots/%s/cErrors.pdf",rapi.Data())); //Print out scaled data points center values and total uncert. cout<<"---- Print out scaled data points center values and total uncert."<<endl; Int_t q=0; cout<<endl; cout<<" -- Scaled reference before rebin"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"pT bins[]"; cout<<" = {"; for(q=0;q<da_BIN_NUM;q++) { if(q!=0) cout<<", "; TString sptbin = Form("(%.1f,%.1f)",da_ptbin[q],da_ptbin[q+1]); cout<<setiosflags(std::ios::left)<<setw(12)<<sptbin; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Center value[]"; cout<<" = {"; for(q=0;q<da_BIN_NUM;q++) { if(q!=0) cout<<", "; cout<<setiosflags(std::ios::left)<<setw(12)<<acrosssec[q]; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Up errors[]"; cout<<" = {"; for(q=0;q<da_BIN_NUM;q++) { if(q!=0) cout<<", "; cout<<setiosflags(std::ios::left)<<setw(12)<<amaxErr[q]; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Relative Up errors[]"; cout<<" = {"; for(q=0;q<da_BIN_NUM;q++) { if(q!=0) cout<<", "; TString percsign = "%"; TString sperc = Form("%.2f%s",amaxErrrel[q]*100.,percsign.Data()); cout<<setiosflags(std::ios::left)<<setw(12)<<sperc; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Dw errors[]"; cout<<" = {"; for(q=0;q<da_BIN_NUM;q++) { if(q!=0) cout<<", "; cout<<setiosflags(std::ios::left)<<setw(12)<<aminErr[q]; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Relative Dw errors[]"; cout<<" = {"; for(q=0;q<da_BIN_NUM;q++) { if(q!=0) cout<<", "; TString percsign = "%"; TString sperc = Form("%.2f%s",aminErrrel[q]*100.,percsign.Data()); cout<<setiosflags(std::ios::left)<<setw(12)<<sperc; } cout<<"};"<<endl; cout<<endl; //Plot and fit scaled data points cout<<"---- Plot and fit scaled data"<<endl; cout<<" -- Plot scaled data with total uncertainty"<<endl; Double_t iexl[da_BIN_NUM],iexr[da_BIN_NUM]; for(i=0;i<da_BIN_NUM;i++) { iexl[i] = da_bincenter[i]-da_ptbin[i]; iexr[i] = da_ptbin[i+1]-da_bincenter[i]; } TGraphAsymmErrors* gcrosssec_rescaled = new TGraphAsymmErrors(da_BIN_NUM, da_bincenter, acrosssec, iexl, iexr, aminErr, amaxErr); gcrosssec_rescaled->SetMarkerStyle(20); gcrosssec_rescaled->SetMarkerSize(0.7); gcrosssec_rescaled->SetMarkerColor(kBlack); gcrosssec_rescaled->SetLineWidth(2); gcrosssec_rescaled->SetLineColor(kBlack); TCanvas* crescaled = new TCanvas("crescaled","",400,400); crescaled->SetLogy(); TH2F* hempty_crescaled=new TH2F("hempty_crescaled","",10,0,20.,10.,1.e-2,1.e+3); hempty_crescaled->SetStats(0); hempty_crescaled->GetXaxis()->SetTitle("p_{T} (GeV/c)"); hempty_crescaled->GetYaxis()->SetTitle("Scaled d#sigma(D^{0})/dp_{T}(#mub GeV-1c)"); hempty_crescaled->GetXaxis()->SetTitleOffset(1.); hempty_crescaled->GetYaxis()->SetTitleOffset(.9); hempty_crescaled->GetXaxis()->SetTitleSize(0.045); hempty_crescaled->GetYaxis()->SetTitleSize(0.045); hempty_crescaled->GetXaxis()->SetTitleFont(42); hempty_crescaled->GetYaxis()->SetTitleFont(42); hempty_crescaled->GetXaxis()->SetLabelFont(42); hempty_crescaled->GetYaxis()->SetLabelFont(42); hempty_crescaled->GetXaxis()->SetLabelSize(0.04); hempty_crescaled->GetYaxis()->SetLabelSize(0.04); hempty_crescaled->Draw(); gcrosssec_rescaled->Draw("psame"); TLegend* legcrosssec_rescaled = new TLegend(0.60,0.80,0.90,0.90); legcrosssec_rescaled->SetFillColor(0); legcrosssec_rescaled->SetBorderSize(0); legcrosssec_rescaled->AddEntry(gcrosssec_rescaled,"Total unc.","lep"); legcrosssec_rescaled->Draw("same"); //Fit scaled data points cout<<" -- Fit scaled data"<<endl; TF1* fdata = new TF1("fdata","pow(10,[0]*exp([1]*x)+[2])",da_ptbin[0],da_ptbin[da_BIN_NUM]); //fdata->SetParameter(1,-0.055); fdata->SetParLimits(1,-0.100,-0.055); fdata->SetParLimits(0,5.,8.); fdata->SetParLimits(2,-4.,-2.); //TF1* fdata = new TF1("fdata","pow(10,[0]*exp([1]*x)+[2])",da_ptbin[0],da_ptbin[da_BIN_NUM]); //fdata->SetParLimits(1,-0.070,-0.055); //fdata->SetParLimits(0,5.,7.); //fdata->SetParLimits(2,-4.,-3.); //TF1* fdata = new TF1("fdata"," exp([1]+[2]*x+[3]*x*x+[4]*x*x*x)",da_ptbin[0],da_ptbin[da_BIN_NUM]); //fdata->SetParameter(1,6.91); //fdata->SetParameter(2,-0.72); //fdata->SetParLimits(3,-0.01,0.008); //fdata->SetParLimits(4,0.0008,0.0012); gcrosssec_rescaled->Fit("fdata","q","",da_ptbin[1],da_ptbin[da_BIN_NUM]); cout<<fdata->GetParameter(0)<<" "<<fdata->GetParameter(1)<<" "<<fdata->GetParameter(2)<<" "<<fdata->GetParameter(3)<<endl; crescaled->SaveAs(Form("plots/%s/rescaled.pdf",rapi.Data())); //Rebin into 2.76TeV PbPb ptbins cout<<"---- Rebin into 2.76TeV PbPb ptbins"<<endl; TH1F* hfitref = new TH1F("hfitref","",BIN_NUM,ptbin); TH1F* hfitreffitDoublecheck = new TH1F("hfitreffitDoublecheck","",da_BIN_NUM,da_ptbin); Double_t integ; Double_t afinalsc[BIN_NUM],afinapt[BIN_NUM],afinaptl[BIN_NUM]; Double_t afinalupWeighted[BIN_NUM],afinaldwWeighted[BIN_NUM],afinaluprelWeighted[BIN_NUM],afinaldwrelWeighted[BIN_NUM]; Double_t afinalupUnWeighted[BIN_NUM],afinaldwUnWeighted[BIN_NUM],afinaluprelUnWeighted[BIN_NUM],afinaldwrelUnWeighted[BIN_NUM]; Double_t afitDoublecheck[da_BIN_NUM]; //Calculate error rebin fraction cout<<" -- Calculate error rebin fraction"<<endl; Double_t afracWeighted[BIN_NUM][COB_NUM],afracUnWeighted[BIN_NUM][COB_NUM]; for(i=0;i<BIN_NUM;i++) { for(j=0;j<COB_NUM;j++) { afracWeighted[i][j]=0; afracUnWeighted[i][j]=0; } } for(i=0;i<BIN_NUM;i++) { for(j=0;j<COB_NUM;j++) { if(ind[i][j]>-1) { afracWeighted[i][j] = fdata->Integral(lowridge[i][j],highridge[i][j]) / fdata->Integral(ptbin[i],ptbin[i+1]); afracUnWeighted[i][j] = (highridge[i][j]-lowridge[i][j]) / (ptbin[i+1]-ptbin[i]); } } } cout<<" -- Rebin center value by fitting function"<<endl; cout<<" -- Rebin uncertainties by statistic weight"<<endl; for(i=0;i<da_BIN_NUM;i++) { integ = fdata->Integral(da_ptbin[i],da_ptbin[i+1])/hfitreffitDoublecheck->GetBinWidth(i+1); afitDoublecheck[i] = integ/acrosssec[i]; } TGraph* gfitDoublecheck = new TGraph(da_BIN_NUM,da_ptctr,afitDoublecheck); TCanvas* cfitDoublecheck = new TCanvas("cfitDoublecheck","",500,500); TH2F* hempty_cfitDoublecheck = new TH2F("hempty_cfitDoublecheck","",10,0,17.,10.,0.2,2.2); hempty_cfitDoublecheck->SetStats(0); hempty_cfitDoublecheck->GetXaxis()->SetTitle("p_{T} (GeV/c)"); hempty_cfitDoublecheck->GetYaxis()->SetTitle("#sigma(scaled data)/#sigma(rebin by fit)"); hempty_cfitDoublecheck->GetXaxis()->SetTitleOffset(1.); hempty_cfitDoublecheck->GetYaxis()->SetTitleOffset(.9); hempty_cfitDoublecheck->GetXaxis()->SetTitleSize(0.045); hempty_cfitDoublecheck->GetYaxis()->SetTitleSize(0.045); hempty_cfitDoublecheck->GetXaxis()->SetTitleFont(42); hempty_cfitDoublecheck->GetYaxis()->SetTitleFont(42); hempty_cfitDoublecheck->GetXaxis()->SetLabelFont(42); hempty_cfitDoublecheck->GetYaxis()->SetLabelFont(42); hempty_cfitDoublecheck->GetXaxis()->SetLabelSize(0.04); hempty_cfitDoublecheck->GetYaxis()->SetLabelSize(0.04); hempty_cfitDoublecheck->Draw(); gfitDoublecheck->SetMarkerStyle(2); gfitDoublecheck->SetMarkerSize(2); gfitDoublecheck->Draw("psame"); cfitDoublecheck->SaveAs(Form("plots/%s/cfitDoublecheck.pdf",rapi.Data())); for(i=0;i<BIN_NUM;i++) { integ = fdata->Integral(ptbin[i],ptbin[i+1])/hfitref->GetBinWidth(i+1); afinalsc[i] = integ; hfitref->SetBinContent(i+1,integ); afinalupWeighted[i]=0; afinalupUnWeighted[i]=0; afinaldwWeighted[i]=0; afinaldwUnWeighted[i]=0; for(j=0;j<COB_NUM;j++) { if(ind[i][j]<0) continue; afinaldwrelWeighted[i]+=aminErrrel[ind[i][j]]*afracWeighted[i][j]; afinaldwWeighted[i] = afinaldwrelWeighted[i]*afinalsc[i]; afinaluprelWeighted[i]+=amaxErrrel[ind[i][j]]*afracWeighted[i][j]; afinalupWeighted[i] = afinaluprelWeighted[i]*afinalsc[i]; afinaldwrelUnWeighted[i]+=aminErrrel[ind[i][j]]*afracUnWeighted[i][j]; afinaldwUnWeighted[i] = afinaldwrelUnWeighted[i]*afinalsc[i]; afinaluprelUnWeighted[i]+=amaxErrrel[ind[i][j]]*afracUnWeighted[i][j]; afinalupUnWeighted[i] = afinaluprelUnWeighted[i]*afinalsc[i]; } afinapt[i] = hfitref->GetBinCenter(i+1); afinaptl[i] = hfitref->GetBinWidth(i+1)/2.; } //Print out 2.76TeV data-driven pp reference values cout<<"---- Print out 2.76TeV data-driven pp reference results"<<endl; cout<<endl; //weighted cout<<" -- Final reference after rebin"<<endl; if(displayAreaUnweighted) cout<<" -- Area Weighted"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"pT bins[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; TString sptbin = Form("(%.1f,%.1f)",ptbin[q],ptbin[q+1]); cout<<setiosflags(std::ios::left)<<setw(12)<<sptbin; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Center value[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; cout<<setiosflags(std::ios::left)<<setw(12)<<afinalsc[q]; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Up errors[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; cout<<setiosflags(std::ios::left)<<setw(12)<<afinalupWeighted[q]; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Relative Up errors[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; TString percsign = "%"; TString sperc = Form("%.2f%s",afinaluprelWeighted[q]*100,percsign.Data()); cout<<setiosflags(std::ios::left)<<setw(12)<<sperc; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Dw errors[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; cout<<setiosflags(std::ios::left)<<setw(12)<<afinaldwWeighted[q]; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Relative Dw errors[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; TString percsign = "%"; TString sperc = Form("%.2f%s",afinaldwrelWeighted[q]*100,percsign.Data()); cout<<setiosflags(std::ios::left)<<setw(12)<<sperc; } cout<<"};"<<endl; //unweighted if(displayAreaUnweighted) { cout<<" -- Area UnWeighted"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"pT bins[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; TString sptbin = Form("(%.1f,%.1f)",ptbin[q],ptbin[q+1]); cout<<setiosflags(std::ios::left)<<setw(12)<<sptbin; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Center value[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; cout<<setiosflags(std::ios::left)<<setw(12)<<afinalsc[q]; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Up errors[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; cout<<setiosflags(std::ios::left)<<setw(12)<<afinalupUnWeighted[q]; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Relative Up errors[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; TString percsign = "%"; TString sperc = Form("%.2f%s",afinaluprelUnWeighted[q]*100,percsign.Data()); cout<<setiosflags(std::ios::left)<<setw(12)<<sperc; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Dw errors[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; cout<<setiosflags(std::ios::left)<<setw(12)<<afinaldwUnWeighted[q]; } cout<<"};"<<endl; cout<<setiosflags(std::ios::left)<<" "<<setw(20)<<"Relative Dw errors[]"; cout<<" = {"; for(q=0;q<BIN_NUM;q++) { if(q!=0) cout<<", "; TString percsign = "%"; TString sperc = Form("%.2f%s",afinaldwrelUnWeighted[q]*100,percsign.Data()); cout<<setiosflags(std::ios::left)<<setw(12)<<sperc; } cout<<"};"<<endl; } cout<<endl; //Plot 2.76TeV data-driven pp reference cout<<"---- Plot rebinned 2.76TeV data-driven pp reference"<<endl; TGraphAsymmErrors* gfinalref = new TGraphAsymmErrors(BIN_NUM, afinapt, afinalsc, afinaptl, afinaptl, afinaldwWeighted, afinalupWeighted); gfinalref->SetMarkerStyle(20); gfinalref->SetMarkerSize(0.7); gfinalref->SetMarkerColor(kBlack); gfinalref->SetLineWidth(2); gfinalref->SetLineColor(kBlack); TCanvas* cfinalref = new TCanvas("cfinalref","",400,400); cfinalref->SetLogy(); TH2F* hempty_cfinalref = new TH2F("hempty_cfinalref","",10,0,20.,10.,1.e-2,1.e+3); hempty_cfinalref->SetStats(0); hempty_cfinalref->GetXaxis()->SetTitle("p_{t} (GeV/c)"); hempty_cfinalref->GetYaxis()->SetTitle("Fitted d#sigma(D^{0})/dp_{T}(#mub/(GeV/c))"); hempty_cfinalref->GetXaxis()->SetTitleOffset(1.); hempty_cfinalref->GetYaxis()->SetTitleOffset(.9); hempty_cfinalref->GetXaxis()->SetTitleSize(0.045); hempty_cfinalref->GetYaxis()->SetTitleSize(0.045); hempty_cfinalref->GetXaxis()->SetTitleFont(42); hempty_cfinalref->GetYaxis()->SetTitleFont(42); hempty_cfinalref->GetXaxis()->SetLabelFont(42); hempty_cfinalref->GetYaxis()->SetLabelFont(42); hempty_cfinalref->GetXaxis()->SetLabelSize(0.04); hempty_cfinalref->GetYaxis()->SetLabelSize(0.04); hempty_cfinalref->Draw(); gfinalref->Draw("psame"); cfinalref->SaveAs(Form("plots/%s/finalref.pdf",rapi.Data())); //Plot ratio of data-driven pp reference and pure FONLL cout<<"---- Plot ratio of data-driven pp reference and FONLL"<<endl; TH1F* hptAnlyRef_rebin = (TH1F*)hptAnlyRef->Rebin(BIN_NUM,"hptAnlyRef_rebin",ptbin); for(i=0;i<BIN_NUM;i++) { hptAnlyRef_rebin->SetBinContent(i+1,hptAnlyRef_rebin->GetBinContent(i+1)/(hptAnlyRef_rebin->GetBinWidth(i+1)*4)); } Double_t aratiosc[BIN_NUM],aratioup[BIN_NUM],aratiodw[BIN_NUM]; for(i=0;i<BIN_NUM;i++) { aratiosc[i] = afinalsc[i]/hptAnlyRef_rebin->GetBinContent(i+1); aratioup[i] = afinalupWeighted[i]/hptAnlyRef_rebin->GetBinContent(i+1); aratiodw[i] = afinaldwWeighted[i]/hptAnlyRef_rebin->GetBinContent(i+1); } TGraphAsymmErrors* gratioref = new TGraphAsymmErrors(BIN_NUM, afinapt, aratiosc, afinaptl, afinaptl, aratiodw, aratioup); gratioref->SetMarkerStyle(20); gratioref->SetMarkerSize(0.7); gratioref->SetMarkerColor(kBlack); gratioref->SetLineWidth(2); gratioref->SetLineColor(kBlack); TCanvas* cratioref = new TCanvas("cratioref","",400,400); TH2F* hempty_cratioref = new TH2F("hempty_cratioref","",10,0,18.,10.,0.,3.5); hempty_cratioref->SetStats(0); hempty_cratioref->GetXaxis()->SetTitle("p_{T} (GeV/c)"); hempty_cratioref->GetYaxis()->SetTitle("data/FONLL"); hempty_cratioref->GetXaxis()->SetTitleOffset(1.); hempty_cratioref->GetYaxis()->SetTitleOffset(.9); hempty_cratioref->GetXaxis()->SetTitleSize(0.045); hempty_cratioref->GetYaxis()->SetTitleSize(0.045); hempty_cratioref->GetXaxis()->SetTitleFont(42); hempty_cratioref->GetYaxis()->SetTitleFont(42); hempty_cratioref->GetXaxis()->SetLabelFont(42); hempty_cratioref->GetYaxis()->SetLabelFont(42); hempty_cratioref->GetXaxis()->SetLabelSize(0.04); hempty_cratioref->GetYaxis()->SetLabelSize(0.04); hempty_cratioref->Draw(); gratioref->Draw("psame"); cratioref->SaveAs(Form("plots/%s/ratioref.pdf",rapi.Data())); cout<<endl; }
void plotcf(const char* sys="PP", const char* kT="kT1", const char* proj="Out", int mult=2, TString dir = "../train_results_central_dcaptdep", int period=11, int numofpsibins = 6) { int seppsi = 0; // indicates if draw in separate psi bins int psibins = 0; // indicates if one uses psi binning int fname = 1; // indicates if the file name is specified int plotinpsibins = 0; int rb = 1; // flag to rebinning if (mult<2) const char* centrality = "central"; else const char* centrality = "semicentral"; if (period == 11) { const int Nruns = 64; // const int Nruns = 66; int runs[Nruns] = { 167915, 168115, 168460, 169035, 169238, 169859, 170228 , 167920 // , 168310 , 168464, 169091, 169411, 169923, 170230, 167985, 168311, 169094, 169415, 170027, 170268, 167987, 168322, 168511, 169138, 169417, 170081, 170269, 167988, 168325, 168512, 169144, 169835, 170155, 170270, 168069, 168341, 168514, 169145, 169837, 170159, 170306// , 168076 , 168342, 168777, 169148, 169838, 170163, 170308, 168105, 168361, 168826, 169156, 169846, 170193, 170309, 168107 // ,168362 , 168988, 169160, 169855, 170203, 168108 , 168458, 168992, 169167, 169858, 170204 }; // const int Nruns = 62; // int runs[Nruns] = { // 167915, 168115, 168460, 169035, 169238, 169859, 170228 , // 167920 , // 168310, 168464, 169091, 169411, 169923, 170230, 167985, 168311, 169094, 169415, 170027, 170268, 167987, 168322, 168511, 169138, 169417, 170081, 170269, 167988, 168325, 168512, 169144, 169835, 170155, 170270, 168069, // 168341, // 168514, 169145, 169837, 170159, 170306, 168076, 168342, 168777, // 169148, // 169838, 170163, 170308, 168105, 168361, 168826, 169156, 169846, 170193, 170309, 168107, 168362, // 168988, // // 169160, // 169855, 170203, 168108 , 168458, 168992, // 169167, 169858, 170204 // }; } else if (period == 10) { const int Nruns = 89; int runs[Nruns] = { 139510, 139507, 139505, 139503, 139465, 139438, 139437, 139360, 139329, 139328, 139314, 139310, 139309, 139173, 139107, 139105, 139038, 139037, 139036, 139029, 139028, 138872, 138871, 138870, 138837, 138732, 138730, 138666, 138662, 138653, 138652, 138638, 138624, 138621, 138583, 138582, 138579, 138578, 138534, 138469, 138442, 138439, 138438, 138396, 138364, 138275, 138225, 138201, 138197, 138192, 138190, 137848, 137844, 137752, 137751, 137724, 137722, 137718, 137704, 137693, 137692, 137691, 137686, 137685, 137639, 137638, 137608, 137595, 137549, 137544, 137541, 137539, 137443, 137441, 137440, 137439, 137434, 137432, 137431, 137430, 137366, 137243, 137236, 137235, 137232, 137231, 137230, 137162, 137161}; } TFile* ifile_[Nruns+1]; if (plotinpsibins) { for (int jf = 0 ; jf < Nruns; ++jf ) { ifile_[jf] = new TFile(Form("%s/%d.mergedbinsdir.root",dir.Data(),runs[jf]), "read"); } } if (fname) ifile_[Nruns] = new TFile(Form("%s",dir.Data()), "read"); else ifile_[Nruns] = new TFile(Form("%s/allrunsmergedbins.root",dir.Data()), "read"); TH1D* numpp[13][3][Nruns+1]; TH1D* denpp[13][3][Nruns+1]; TH1D* numpapoutp[13][3]; TH1D* numpapoutn[13][3]; TH1D* numpaplongp[13][3]; TH1D* numpaplongn[13][3]; TH1D* numpapsidep[13][3]; TH1D* numpapsiden[13][3]; TH1D* denpapoutp[13][3]; TH1D* denpapoutn[13][3]; TH1D* denpaplongp[13][3]; TH1D* denpaplongn[13][3]; TH1D* denpapsidep[13][3]; TH1D* denpapsiden[13][3]; TH1D* numsum; TH1D* densum; TCanvas *myCan = new TCanvas("asd","asd"); myCan->Draw(); myCan->cd(); TPad *myPad = new TPad("myPad", "The pad",0,0,1,1); myPadSetUp(myPad,0.15,0.04,0.04,0.15); myPad->Draw(); myPad->cd(); TGraph* grnument[13]; TH2D* hnument = new TH2D("hipsiif","hipsiif",numofpsibins,-0.5,numofpsibins,Nruns,-0.5,Nruns); TFile* grofile = new TFile("grofile.root","recreate"); if (plotinpsibins) { // _________________________________________________ // // Psi binning..... // _________________________________________________ // each numerator and denominator from different run for (int iPsi = 0; iPsi < numofpsibins; ++iPsi) { grnument[iPsi] = new TGraph(); for (int iif = 0; iif < Nruns; ++iif ) { // cout << Form("NumcqinvPPtpcM3Psi%d%s",iPsi,kT) << endl; // cout << Form("Numcqinv%stpcM%dPsi%d%s",sys,mult,iPsi,kT) << endl; // cout << "iPsi = " << iPsi << endl; // // cout << "ikT = " << ikT << endl; // cout << "iif = " << iif << endl << endl; bool exi = false; if (iPsi == 0) { if (strcmp(sys,"PAP") != 0) { if ( ifile_[iif]->GetListOfKeys()->Contains(Form("Numcqinv%stpcM%dPsi%d%s",sys,mult,iPsi,kT)) ) { exi = true; numsum = (TH1D*)ifile_[iif]->Get(Form("Numcqinv%stpcM%dPsi%d%s",sys,mult,iPsi,kT)); densum = (TH1D*)ifile_[iif]->Get(Form("Dencqinv%stpcM%dPsi%d%s",sys,mult,iPsi,kT)); grnument[iPsi]->SetPoint(grnument[iPsi]->GetN(), iif, numsum->GetEntries()); hnument->SetBinContent(iPsi+1, iif, numsum->GetEntries()); if (densum->GetEntries()==0) { cout << "iPsi = " << iPsi << endl; cout << "iif = " << iif << endl << endl; } } } else { exi = true; numsum = (TH1D*)ifile_[iif]->Get(Form("Num%sPckstarPAPtpcM%dPsi%d%s",proj,mult,iPsi,kT)); densum = (TH1D*)ifile_[iif]->Get(Form("Den%sPckstarPAPtpcM%dPsi%d%s",proj,mult,iPsi,kT)); numsumN = (TH1D*)ifile_[iif]->Get(Form("Num%sNckstarPAPtpcM%dPsi%d%s",proj,mult,iPsi,kT)); densumN = (TH1D*)ifile_[iif]->Get(Form("Den%sNckstarPAPtpcM%dPsi%d%s",proj,mult,iPsi,kT)); grnument[iPsi]->SetPoint(grnument[iPsi]->GetN(), iif, numsum->GetEntries()); hnument->SetBinContent(iPsi+1, iif, numsum->GetEntries()); // numsum->SetBit(TH1::kIsAverage); // densum->SetBit(TH1::kIsAverage); // numsumN->SetBit(TH1::kIsAverage); // densumN->SetBit(TH1::kIsAverage); } if (exi) if (!seppsi) { densum->Scale(numsum->GetEntries()/densum->GetEntries()); } if (strcmp(sys,"PAP") == 0) { densumN->Scale(numsumN->GetEntries()/densumN->GetEntries()); } } else { if (strcmp(sys,"PAP") != 0) { if ( ifile_[iif]->GetListOfKeys()->Contains(Form("Numcqinv%stpcM%dPsi%d%s",sys,mult,iPsi,kT)) ) { exi = true; numpp[iPsi][2][iif] = (TH1D*)ifile_[iif]->Get(Form("Numcqinv%stpcM%dPsi%d%s",sys,mult,iPsi,kT)); denpp[iPsi][2][iif] = (TH1D*)ifile_[iif]->Get(Form("Dencqinv%stpcM%dPsi%d%s",sys,mult,iPsi,kT)); grnument[iPsi]->SetPoint(grnument[iPsi]->GetN(), iif, numpp[iPsi][2][iif]->GetEntries()); hnument->SetBinContent(iPsi+1, iif, numpp[iPsi][2][iif]->GetEntries()); // cout << iPsi << endl; // cout << numpp[iPsi][2][iif]->GetEntries() << endl; // // cout << denpp[iPsi][2][iif]->GetEntries() << endl; // cout << endl; if (denpp[iPsi][2][iif]->GetEntries()==0) { cout << denpp[iPsi][2][iif]->GetEntries() << endl; cout << "iPsi = " << iPsi << endl; cout << "iif = " << iif << endl; } } } else { exi = true; numpp[iPsi][2][iif] = (TH1D*)ifile_[iif]->Get(Form("Num%sPckstarPAPtpcM%dPsi%d%s",proj,mult,iPsi,kT)); denpp[iPsi][2][iif] = (TH1D*)ifile_[iif]->Get(Form("Den%sPckstarPAPtpcM%dPsi%d%s",proj,mult,iPsi,kT)); numpp[iPsi][0][iif] = (TH1D*)ifile_[iif]->Get(Form("Num%sNckstarPAPtpcM%dPsi%d%s",proj,mult,iPsi,kT)); denpp[iPsi][0][iif] = (TH1D*)ifile_[iif]->Get(Form("Den%sNckstarPAPtpcM%dPsi%d%s",proj,mult,iPsi,kT)); // numpp[iPsi][2][iif]->SetBit(TH1::kIsAverage); // denpp[iPsi][2][iif]->SetBit(TH1::kIsAverage); // numpp[iPsi][0][iif]->SetBit(TH1::kIsAverage); // denpp[iPsi][0][iif]->SetBit(TH1::kIsAverage); grnument[iPsi]->SetPoint(grnument[iPsi]->GetN(), iif, numpp[iPsi][2][iif]->GetEntries()); hnument->SetBinContent(iPsi+1, iif, numpp[iPsi][2][iif]->GetEntries()); } if (exi) { numsum->Add(numpp[iPsi][2][iif]); if (!seppsi) denpp[iPsi][2][iif]->Scale(numpp[iPsi][2][iif]->GetEntries()/denpp[iPsi][2][iif]->GetEntries()); densum->Add(denpp[iPsi][2][iif]); if (strcmp(sys,"PAP") == 0) { numsumN->Add(numpp[iPsi][0][iif]); denpp[iPsi][0][iif]->Scale(numpp[iPsi][0][iif]->GetEntries()/denpp[iPsi][0][iif]->GetEntries()); densumN->Add(denpp[iPsi][0][iif]); } } } // int rb = 2; // if (exi) { // cout << "exi" << endl; // numsum->Rebin(rb); // } // densum->Rebin(rb); // numsum->Divide(densum); // numsum->SetMarkerColor(1+iPsi); // numsum->SetMarkerStyle(20); // numsum->SetMarkerSize(1.0); // if (iPsi == 0) // numsum->Draw("p"); // else // numsum->Draw("psame"); } if (seppsi) { double norm = numsum->GetEntries()/densum->GetEntries(); cout << iPsi << " " << norm << endl; TH1F *hnew = (TH1F*)densum->Clone("hnew"); hnew->Scale(norm); numsum->SetMarkerColor(iPsi+1); numsum->SetMarkerStyle(20); numsum->SetMarkerSize(1.0); int rb = 1; numsum->Rebin(rb); // densum->Rebin(rb); // numsum->Divide(densum); hnew->Rebin(rb); numsum->Divide(hnew); if (iPsi == 0) { numsum->DrawCopy("p"); } else { numsum->DrawCopy("psame"); } // hnument[iPsi][iif]->Write(); } // cout <<"write ipsi = " << iPsi << endl; // grnument[iPsi]->SetName(Form("gr%d",iPsi)); // grnument[iPsi]->Write(); } // hnument->Write(); // numpp[6][2]->Draw("p"); if (!seppsi) { if (strcmp(sys,"PAP")==0) { numsum->SetBit(TH1::kIsAverage); densum->SetBit(TH1::kIsAverage); numsumN->SetBit(TH1::kIsAverage); densumN->SetBit(TH1::kIsAverage); numsum->Add(numsumN); densum->Add(densumN); numsum->ResetBit(TH1::kIsAverage); densum->ResetBit(TH1::kIsAverage); } numsum->SetMarkerColor(kBlue); numsum->SetMarkerStyle(20); numsum->SetMarkerSize(1.0); int rb = 1; numsum->Rebin(rb); densum->Rebin(rb); numsum->Divide(densum); if (psibins) numsum->Draw("p"); // densum->Draw("psame"); } } // _________________________________________________ // // bez Psi binningu..... // _________________________________________________ if (strcmp(sys,"PAP") != 0) { numpp[0][2][Nruns] = (TH1D*)ifile_[Nruns]->Get(Form("Numcqinv%stpcM%dPsi%d%s",sys,mult,numofpsibins,kT)); denpp[0][2][Nruns] = (TH1D*)ifile_[Nruns]->Get(Form("Dencqinv%stpcM%dPsi%d%s",sys,mult,numofpsibins,kT)); numpp[0][2][Nruns]->SetXTitle("#it{q}_{inv} (GeV/#it{c})"); numpp[0][2][Nruns]->SetYTitle("C(#it{q}_{inv})"); // numsum->SetXTitle("#it{q}_{inv} (GeV/#it{c})"); // numsum->SetYTitle("C(#it{q}_{inv})"); } else { numpp[0][2][Nruns] = (TH1D*)ifile_[Nruns]->Get(Form("Num%sPckstarPAPtpcM%dPsi%d%s",proj,mult,numofpsibins,kT)); denpp[0][2][Nruns] = (TH1D*)ifile_[Nruns]->Get(Form("Den%sPckstarPAPtpcM%dPsi%d%s",proj,mult,numofpsibins,kT)); numpp[0][0][Nruns] = (TH1D*)ifile_[Nruns]->Get(Form("Num%sNckstarPAPtpcM%dPsi%d%s",proj,mult,numofpsibins,kT)); denpp[0][0][Nruns] = (TH1D*)ifile_[Nruns]->Get(Form("Den%sNckstarPAPtpcM%dPsi%d%s",proj,mult,numofpsibins,kT)); numpp[0][2][Nruns]->SetBit(TH1::kIsAverage); denpp[0][2][Nruns]->SetBit(TH1::kIsAverage); numpp[0][0][Nruns]->SetBit(TH1::kIsAverage); denpp[0][0][Nruns]->SetBit(TH1::kIsAverage); numpp[0][2][Nruns]->Add(numpp[0][0][Nruns]); denpp[0][2][Nruns]->Add(denpp[0][0][Nruns]); numpp[0][2][Nruns]->ResetBit(TH1::kIsAverage); denpp[0][2][Nruns]->ResetBit(TH1::kIsAverage); numpp[0][2][Nruns]->SetXTitle("#it{k*} (GeV/#it{c})"); numpp[0][2][Nruns]->SetYTitle("C(#it{k*})"); // numsum->SetXTitle("#it{k*} (GeV/#it{c})"); // numsum->SetYTitle("C(#it{k*})"); } gStyle->SetOptStat(0); numpp[0][2][Nruns]->GetXaxis()->SetTitleSize(0.06); numpp[0][2][Nruns]->GetYaxis()->SetTitleSize(0.06); numpp[0][2][Nruns]->SetTitle(""); numpp[0][2][Nruns]->Rebin(rb); denpp[0][2][Nruns]->Rebin(rb); numpp[0][2][Nruns]->SetMarkerColor(kRed); numpp[0][2][Nruns]->SetMarkerStyle(20); numpp[0][2][Nruns]->SetMarkerSize(1.0); // numsum->GetXaxis()->SetTitleSize(0.06); // numsum->GetYaxis()->SetTitleSize(0.06); // numsum->SetTitle(""); // numsum->Rebin(rb); // densum->Rebin(rb); double norm = denpp[0][2][Nruns]->GetEntries()/numpp[0][2][Nruns]->GetEntries(); //double norm = calculateNormalizationFactor(numpp[0][2][Nruns],denpp[0][2][Nruns],0.4,0.45 ); //double norm = calculateNormalizationFactor(numpp[0][2][Nruns],denpp[0][2][Nruns],0.3,0.4 ); numpp[0][2][Nruns]->Divide(denpp[0][2][Nruns]); numpp[0][2][Nruns]->Scale(norm); if (strcmp(sys,"PAP") == 0) { numpp[0][2][Nruns]->SetMaximum(1.5); numpp[0][2][Nruns]->SetMinimum(0.9); // numpp[0][2][Nruns]->GetXaxis()->SetRangeUser(0,0.46); // numpp[0][2][Nruns]->GetXaxis()->SetRangeUser(0,0.5); // numsum->GetXaxis()->SetRangeUser(0,0.6); // numsum->SetMaximum(1.058); // numsum->SetMinimum(0.912); // numsum->SetTitle(""); } else { numpp[0][2][Nruns]->SetMaximum(1.5); numpp[0][2][Nruns]->SetMinimum(0.9); // numsum->SetMaximum(2.2); // numsum->SetMinimum(0.5); // numpp[0][2][Nruns]->GetXaxis()->SetRangeUser(0,0.26); numpp[0][2][Nruns]->GetXaxis()->SetRangeUser(0,0.5); // numsum->GetXaxis()->SetRangeUser(0,0.26); // numsum->GetXaxis()->SetRangeUser(0,0.3); } // uncomment this to compare // if (!psibins) numpp[0][2][Nruns]->Draw("p"); // else // numpp[0][2][Nruns]->Draw("same"); //numpp[0][2][Nruns]->Write(); // if (strcmp(sys,"PAP") ==0 ) { // numpp[0][0][Nruns]->Rebin(rb); // denpp[0][0][Nruns]->Rebin(rb); // numpp[0][0][Nruns]->SetMarkerColor(kBlack); // numpp[0][0][Nruns]->SetMarkerStyle(20); // numpp[0][0][Nruns]->SetMarkerSize(1.0); // double norm = denpp[0][0][Nruns]->GetEntries()/numpp[0][0][Nruns]->GetEntries(); // numpp[0][0][Nruns]->Divide(denpp[0][0][Nruns]); // numpp[0][0][Nruns]->Scale(norm); // // numpp[0][0][Nruns]->Draw("same"); // numsumN->SetMarkerColor(kGreen+2); // numsumN->SetMarkerStyle(20); // numsumN->SetMarkerSize(1.0); // numsumN->Rebin(rb); // densumN->Rebin(rb); // numsumN->Divide(densumN); // // numsumN->Draw("same"); // } // if (psibins) { // TLegend *leg = new TLegend (0.5,0.2,0.7,0.3); // leg->SetFillColor(kWhite); // leg->SetBorderSize(0); // leg->SetTextSize(0.07); // leg->AddEntry(numsum,"w/ #Psi bins","p"); // leg->AddEntry(numpp[0][2][Nruns],"w/o EP cut","p"); // leg->Draw("same"); // } // TString namef( dir(16,dir.Length()) ); // cout << namef << endl; dir.ReplaceAll("/","_"); dir.ReplaceAll("..",""); dir.ReplaceAll(".root",""); dir.ReplaceAll("_train_results_",""); dir.ReplaceAll("_central_",""); dir.ReplaceAll("_semicentral_",""); dir.ReplaceAll("jun19_",""); myCan->SaveAs(Form("figs/cf%s%s%s.png",sys,dir.Data(),kT)); TFile* ofile = new TFile(Form("figs/cf%s%s%s.root",sys,dir.Data(),kT),"recreate"); numpp[0][2][Nruns]->Write(); //numsum->Write(); }
/* void formatCanvas(TCanvas *c){ c->Divide(1,2,0.01,0.01); c->cd(1); c->GetPad(1)->SetLogy(); c->GetPad(1)->SetPad(0.,0.425,1.,1.); c->GetPad(2)->SetPad(0.,0.0,1.,0.425); c->GetPad(2)->SetBottomMargin(0.3); c->GetPad(2)->SetGridy(1); } // divide by bin width void divideBinWidth(TH1 *h) { h->Sumw2(); for (int i=0;i<=h->GetNbinsX();i++) { Float_t val = h->GetBinContent(i); Float_t valErr = h->GetBinError(i); val/=h->GetBinWidth(i); valErr/=h->GetBinWidth(i); h->SetBinContent(i,val); h->SetBinError(i,valErr); } h->GetXaxis()->CenterTitle(); h->GetYaxis()->CenterTitle(); } void cleanup(TH1F *h) { for (int i=1;i<=h->GetNbinsX();i++) { double val1 = h->GetBinContent(i); double valErr1 = h->GetBinError(i); if (valErr1>=val1) { h->SetBinContent(i,0); h->SetBinError(i,0); } } } // rebin the spectra TH1F *rebin(TH1F *h, char *histName) { TH1F *hRebin = new TH1F(Form("%s_rebin",h->GetName()),Form("rebin %s",h->GetTitle()),nbins_recrebin,boundaries_recrebin); for (int i=1;i<=h->GetNbinsX();i++) { double val=h->GetBinContent(i); double valErr=h->GetBinError(i); int binNum = hRebin->FindBin(h->GetBinCenter(i)); double val1 = hRebin->GetBinContent(binNum); double valErr1 = hRebin->GetBinError(binNum); hRebin->SetBinContent(binNum,val+val1); hRebin->SetBinError(binNum,sqrt(valErr1*valErr1+valErr*valErr)); } cleanup(hRebin); hRebin->SetName(histName); return hRebin; } TH1F *rebin2(TH1F *h, char *histName) { TH1F *hRebin = new TH1F(Form("%s_rebin",h->GetName()),Form("rebin %s",h->GetTitle()),nbins_recrebin_2,boundaries_recrebin_2); for (int i=1;i<=h->GetNbinsX();i++) { double val=h->GetBinContent(i); double valErr=h->GetBinError(i); int binNum = hRebin->FindBin(h->GetBinCenter(i)); double val1 = hRebin->GetBinContent(binNum); double valErr1 = hRebin->GetBinError(binNum); hRebin->SetBinContent(binNum,val+val1); hRebin->SetBinError(binNum,sqrt(valErr1*valErr1+valErr*valErr)); } cleanup(hRebin); hRebin->SetName(histName); return hRebin; } void drawText(const char *text, float xp, float yp, int size){ TLatex *tex = new TLatex(xp,yp,text); tex->SetTextFont(63); tex->SetTextSize(size); tex->SetTextColor(kBlack); tex->SetLineWidth(1); //tex->SetTextFont(42); tex->SetNDC(); tex->Draw(); } void putCMSPrel(double x, double y, double size){ TLatex *tex=0; tex = new TLatex(x,y,"CMS Preliminary"); tex->SetTextSize(size); tex->SetLineWidth(2); tex->SetNDC(); tex->Draw(); } void putCMSSim(double x, double y, double size){ TLatex *tex=0; tex = new TLatex(x,y,"CMS Simulation"); tex->SetTextSize(size); tex->SetLineWidth(2); tex->SetNDC(); tex->Draw(); } TLegend *myLegend(double x1,double y1,double x2, double y2) { TLegend *leg = new TLegend(x1,y1,x2,y2); leg->SetBorderSize(0); leg->SetFillStyle(0); return leg; } */ void nlo_comp_macro(int radius = 3){ TH1::SetDefaultSumw2(); gStyle->SetOptStat(0); TFile *fPP = TFile::Open("/net/hisrv0001/home/rkunnawa/WORK/CMSSW_6_0_0/src/result-2013-akVs3PF-cent-1-isFineBin-0/pbpb_pp_merged_chmx_pt_isMC_0_Unfo_2013_akVs3PF_cent_1_isFineBin_0.root"); //TFile *fNLO_err = TFile::Open("fnl4350a_cteq"); TFile *fNLO_nnpdf = TFile::Open("/net/hisrv0001/home/rkunnawa/WORK/CMSSW_6_0_0/src/fnl4350a_nnpdf21-nlo_aspdf_new.root"); TFile *fNLO_cteq = TFile::Open("/net/hisrv0001/home/rkunnawa/WORK/CMSSW_6_0_0/src/fnl4350a_cteq66-nlo_aspdf_all_new.root"); TFile *fNLO_ct10n = TFile::Open("/net/hisrv0001/home/rkunnawa/WORK/CMSSW_6_0_0/src/fnl4350a_ct10n-nlo_aspdf_new.root"); TFile *fNLO_hera = TFile::Open("/net/hisrv0001/home/rkunnawa/WORK/CMSSW_6_0_0/src/fnl4350a_hera15all-nlo_aspdf_new.root"); //alright lets get the unfolded data here: remember we need it for eta range -2 to +2 //TFile* fPP_unfo_R3 = TFile::Open("pp_2013_2760_abs_eta_2_mc_ak3PF.root"); TFile* fPP_unfo_R4 = TFile::Open("/net/hisrv0001/home/rkunnawa/WORK/CMSSW_6_0_0/src/pp_2013_2760_abs_eta_2_mc_ak4PF.root"); TFile* fPP_unfo_R5 = TFile::Open("/net/hisrv0001/home/rkunnawa/WORK/CMSSW_6_0_0/src/pp_2013_2760_abs_eta_2_mc_ak5PF.root"); //TFile *f_unfold_R2 = TFile::Open("/net/hisrv0001/home/rkunnawa/WORK/RAA/CMSSW_5_3_20/src/Output/PbPb_pp_unfold_marguerite_jet80_chMaxjtpt_norawptcut_test_65GeVCut_akPu2PF_20150205_test.root"); TFile *f_unfold_R3 = TFile::Open(Form("Pawan_ntuple_PbPb_pp_calopfpt_ppNoJetidcut_nlobins_R0p%d_without80FakeRemoval_unfold_mcclosure_oppside_trgMC_noSmear_20_eta_20_%dGeVCut_akPF_20150522.root",3,40)); //TFile *f_unfold_R4 = TFile::Open("/net/hisrv0001/home/rkunnawa/WORK/RAA/CMSSW_5_3_20/src/Output/PbPb_pp_unfold_marguerite_jet80_chMaxjtpt_norawptcut_test_65GeVCut_akPu4PF_20150205_test.root"); TH1F* hPP_data_R_3 = (TH1F*)f_unfold_R3->Get("PP_bayesian_unfolded_spectra"); hPP_data_R_3->Print("base"); hPP_data_R_3 = (TH1F*)hPP_data_R_3->Rebin(nbins_yaxian, "PP_bayesian_unfolded_spectra", boundaries_yaxian); divideBinWidth(hPP_data_R_3); hPP_data_R_3->Print("base"); //PP_measured[0] = (TH1F*)f_unfold_R2->Get("PP_measured_unfolded_spectra"); //PP_binbybin[0] = (TH1F*)f_unfold_R2->Get("PP_binbybin_unfolded_spectra"); //TH1F* PP_bayesian[1] = (TH1F*)f_unfold_R4->Get("PP_bayesian_unfolded_spectra"); //PP_measured[1] = (TH1F*)f_unfold_R3->Get("PP_measured_unfolded_spectra"); //PP_binbybin[1] = (TH1F*)f_unfold_R3->Get("PP_binbybin_unfolded_spectra"); TFile fout("pp_2760GeV_nlo_histos.root","RECREATE"); fout.cd(); TH1F* hPP_nnpdf_NLO = (TH1F*)fNLO_nnpdf->Get(Form("h100%d00",radius-1)); TH1F* hPP_cteq_NLO = (TH1F*)fNLO_cteq->Get(Form("h100%d00",radius-1)); TH1F* hPP_ct10n_NLO = (TH1F*)fNLO_ct10n->Get(Form("h100%d00",radius-1)); TH1F* hPP_hera_NLO = (TH1F*)fNLO_hera->Get(Form("h100%d00",radius-1)); //TH1F* hPP_data_R_3 = (TH1F*)fPP_unfo_R3->Get("Unfolded_cent1"); TH1F* hPP_data_R_4 = (TH1F*)fPP_unfo_R4->Get("Unfolded_cent1"); TH1F* hPP_data_R_5 = (TH1F*)fPP_unfo_R5->Get("Unfolded_cent1"); hPP_data_R_3->Scale(5.3*1e3); hPP_data_R_3->Scale(1./5300e6); //hPP_data_R_3->Scale(1./4); //divideBinWidth(hPP_data_R_3); hPP_data_R_4->Scale(1./5300e6); hPP_data_R_4->Scale(1./4); divideBinWidth(hPP_data_R_4); hPP_data_R_5->Scale(1./5300e6); hPP_data_R_5->Scale(1./4); divideBinWidth(hPP_data_R_5); // NLO histograms without any R# at the end correspond to R=0.3 the standard. others are named accordingly TH1F* hPP_nnpdf_NLO_R4 = (TH1F*)fNLO_nnpdf->Get("h100300"); TH1F* hPP_nnpdf_NLO_R2 = (TH1F*)fNLO_nnpdf->Get("h100100"); TH1F* hPP_cteq_NLO_R4 = (TH1F*)fNLO_cteq->Get("h100300"); TH1F* hPP_ct10n_NLO_R4 = (TH1F*)fNLO_ct10n->Get("h100300"); TH1F* hPP_hera_NLO_R4 = (TH1F*)fNLO_hera->Get("h100300"); TH1F* hPP_cteq_NLO_R2 = (TH1F*)fNLO_cteq->Get("h100100"); TH1F* hPP_ct10n_NLO_R2 = (TH1F*)fNLO_ct10n->Get("h100100"); TH1F* hPP_hera_NLO_R2 = (TH1F*)fNLO_hera->Get("h100100"); TH1F* hPP_err = (TH1F*)fNLO_cteq->Get("h100203"); TH1F* hPP_err_R4 = (TH1F*)fNLO_cteq->Get("h100303"); TH1F* hPP_err_R2 = (TH1F*)fNLO_cteq->Get("h100103"); for(int i = 0;i<hPP_nnpdf_NLO->GetNbinsX();i++){ Float_t valErr = hPP_err->GetBinError(i); hPP_nnpdf_NLO->SetBinError(i,valErr); hPP_cteq_NLO->SetBinError(i,valErr); hPP_hera_NLO->SetBinError(i,valErr); hPP_ct10n_NLO->SetBinError(i,valErr); Float_t valErr_R4 = hPP_err_R4->GetBinError(i); hPP_nnpdf_NLO_R4->SetBinError(i,valErr_R4); hPP_cteq_NLO_R4->SetBinError(i,valErr_R4); hPP_ct10n_NLO_R4->SetBinError(i,valErr_R4); hPP_hera_NLO_R4->SetBinError(i,valErr_R4); Float_t valErr_R2 = hPP_err_R2->GetBinError(i); hPP_nnpdf_NLO_R2->SetBinError(i,valErr_R2); hPP_cteq_NLO_R2->SetBinError(i,valErr_R2); hPP_ct10n_NLO_R2->SetBinError(i,valErr_R2); hPP_hera_NLO_R2->SetBinError(i,valErr_R2); } //add the NPC factors char etaWidth[dir][256] = { "n10_eta_p10","n20_eta_p20","n25_eta_n20","n20_eta_n15", "n15_eta_n10","n10_eta_n05","n05_eta_p05","p05_eta_p10", "p10_eta_p15","p15_eta_p20", "n10_eta_p10","n20_eta_p20","n25_eta_n20","n20_eta_n15", "n15_eta_n10","n10_eta_n05","n05_eta_p05","p05_eta_p10", "p10_eta_p15","p15_eta_p20", "n10_eta_p10","n20_eta_p20","n25_eta_n20","n20_eta_n15", "n15_eta_n10","n10_eta_n05","n05_eta_p05","p05_eta_p10", "p10_eta_p15","p15_eta_p20", "n10_eta_p10","n20_eta_p20","n25_eta_n20","n20_eta_n15", "n15_eta_n10","n10_eta_n05","n05_eta_p05","p05_eta_p10", "p10_eta_p15","p15_eta_p20", "n10_eta_p10","n20_eta_p20","n25_eta_n20","n20_eta_n15", "n15_eta_n10","n10_eta_n05","n05_eta_p05","p05_eta_p10", "p10_eta_p15","p15_eta_p20" }; char radius_lable[dir][256] = { "R2","R2","R2","R2","R2","R2","R2","R2","R2","R2", "R3","R3","R3","R3","R3","R3","R3","R3","R3","R3", "R4","R4","R4","R4","R4","R4","R4","R4","R4","R4", "R5","R5","R5","R5","R5","R5","R5","R5","R5","R5", "R7","R7","R7","R7","R7","R7","R7","R7","R7","R7" }; ifstream fin_txt[dir]; int energy = 2760; for(int i = 0;i<dir;i++){ //ostringstream filename; //filename<<"/net/hisrv0001/home/rkunnawa/WORK/RAA/CMSSW_5_3_8_HI_patch2/src/Macros/RAA/nlo_files/input_np_txtfiles/NPC_ak_"<<radius_lable[i]<<etaWidth[i]<<"_energy"<<energy<<".txt"; fin_txt[i].open(Form("/net/hisrv0001/home/rkunnawa/WORK/RAA/CMSSW_5_3_8_HI_patch2_old/src/Macros/RAA/nlo_files/input_np_txtfiles/NPC_ak_%s_%s_energy%d.txt",radius_lable[i],etaWidth[i],energy)); } //apply the correction factors to the NLO histograms Float_t npc = 0; Float_t bin = 0; //before applying the corrections, lets get a clone of the uncorrected histogram. TH1F* hPP_nnpdf_NLO_noNPC = (TH1F*)hPP_nnpdf_NLO->Clone("hPP_nnpdf_NLO_noNPC"); int counter = 0; while(1){ fin_txt[11]>>bin>>npc; cout<<bin<<" "<<npc<<endl; if(!fin_txt[11].good())break; int bin_no = hPP_nnpdf_NLO->FindBin(bin); //cout<<"bin no = "<<bin_no<<endl; //cout<<"boundaries_pt of bin no"<<boundaries_yaxian_large[bin_no]<<endl; cout<<"value before applying = "<<hPP_nnpdf_NLO->GetBinContent(bin_no)<<endl; hPP_nnpdf_NLO->SetBinContent(bin_no,npc*hPP_nnpdf_NLO->GetBinContent(bin_no)); cout<<"value after applying = "<<hPP_nnpdf_NLO->GetBinContent(bin_no)<<endl; hPP_cteq_NLO->SetBinContent(bin_no,npc*hPP_cteq_NLO->GetBinContent(bin_no)); hPP_ct10n_NLO->SetBinContent(bin_no,npc*hPP_ct10n_NLO->GetBinContent(bin_no)); hPP_hera_NLO->SetBinContent(bin_no,npc*hPP_hera_NLO->GetBinContent(bin_no)); fin_txt[1]>>bin>>npc; if(!fin_txt[1].good())break; bin_no = hPP_nnpdf_NLO_R2->FindBin(bin); hPP_nnpdf_NLO_R2->SetBinContent(bin_no,npc*hPP_nnpdf_NLO_R2->GetBinContent(bin_no)); hPP_cteq_NLO_R2->SetBinContent(bin_no,npc*hPP_cteq_NLO_R2->GetBinContent(bin_no)); hPP_ct10n_NLO_R2->SetBinContent(bin_no,npc*hPP_ct10n_NLO_R2->GetBinContent(bin_no)); hPP_hera_NLO_R2->SetBinContent(bin_no,npc*hPP_hera_NLO_R2->GetBinContent(bin_no)); fin_txt[21]>>bin>>npc; if(!fin_txt[21].good())break; bin_no = hPP_nnpdf_NLO_R4->FindBin(bin); hPP_nnpdf_NLO_R4->SetBinContent(bin_no,npc*hPP_nnpdf_NLO_R4->GetBinContent(bin_no)); hPP_cteq_NLO_R4->SetBinContent(bin_no,npc*hPP_cteq_NLO_R4->GetBinContent(bin_no)); hPP_ct10n_NLO_R4->SetBinContent(bin_no,npc*hPP_ct10n_NLO_R4->GetBinContent(bin_no)); hPP_hera_NLO_R4->SetBinContent(bin_no,npc*hPP_hera_NLO_R4->GetBinContent(bin_no)); counter++; } cout<<"counter = "<<counter<<endl; //get a clone after applying the corrections, TH1F* hPP_nnpdf_NLO_NPC = (TH1F*)hPP_nnpdf_NLO->Clone("hPP_nnpdf_NLO_NPC"); TH1F* hPP_NPC_ratio = (TH1F*)hPP_nnpdf_NLO_NPC->Clone("hPP_NPC_ratio"); hPP_NPC_ratio->Divide(hPP_nnpdf_NLO_noNPC); /* TCanvas *cnpc = new TCanvas("cnpc","",800,600); //cnpc->SetLogy(); hPP_NPC_ratio->SetTitle("NPC 2.76 TeV R=0.3"); hPP_NPC_ratio->SetXTitle("Jet p_{T} (GeV/c)"); hPP_NPC_ratio->SetYTitle("NP factors"); hPP_NPC_ratio->SetAxisRange(0.7,1.3,"Y"); hPP_NPC_ratio->Draw(); cnpc->SaveAs("pp_2760_npc_R3.pdf","RECREATE"); */ hPP_nnpdf_NLO->SetName("hPP_nnpdf_NLO"); hPP_cteq_NLO->SetName("hPP_cteq_NLO"); hPP_ct10n_NLO->SetName("hPP_ct10n_NLO"); hPP_hera_NLO->SetName("hPP_hera_NLO"); hPP_nnpdf_NLO_R2->SetName("hPP_nnpdf_NLO_R2"); hPP_nnpdf_NLO_R2->Print("base"); hPP_cteq_NLO_R2->SetName("hPP_cteq_NLO_R2"); hPP_cteq_NLO_R2->Print("base"); hPP_ct10n_NLO_R2->SetName("hPP_ct10n_NLO_R2"); hPP_ct10n_NLO_R2->Print("base"); hPP_hera_NLO_R2->SetName("hPP_hera_NLO_R2"); hPP_nnpdf_NLO_R4->SetName("hPP_nnpdf_NLO_R4"); hPP_cteq_NLO_R4->SetName("hPP_cteq_NLO_R4"); hPP_ct10n_NLO_R4->SetName("hPP_ct10n_NLO_R4"); hPP_hera_NLO_R4->SetName("hPP_hera_NLO_R4"); hPP_nnpdf_NLO->Write(); hPP_cteq_NLO->Write(); hPP_ct10n_NLO->Write(); hPP_hera_NLO->Write(); hPP_nnpdf_NLO_R2->Write(); hPP_cteq_NLO_R2->Write(); hPP_ct10n_NLO_R2->Write(); hPP_hera_NLO_R2->Write(); hPP_nnpdf_NLO_R4->Write(); hPP_cteq_NLO_R4->Write(); hPP_ct10n_NLO_R4->Write(); hPP_hera_NLO_R4->Write(); TH1F* hPPrebin = (TH1F*)hPP_data_R_3->Clone("hPPrebin"); //TH1F* hPPrebin_test = (TH1F*)faditya->Get("Corrected Jet Spectrum Aditya"); //TH1F* hPPrebin = (TH1F*)hPPrebin_test->Rebin(nbins_yaxian_large,"hPPrebin",boundaries_yaxian_large); //TH1F* hPPunfo = (TH1F*)fPP->Get("Unfolded_cent6"); TH1F* hPPgen = (TH1F*)fPP->Get("hGen_cent1"); //hPPrebin->Scale(64);//remove the sigma scaling from the previous macros //dont need this now since we are taking it from a dedicated macro which gives us diff cross section hPP_data_R_3->Scale(1e9); hPP_data_R_4->Scale(1e9); hPP_data_R_5->Scale(1e9); //hPP_nnpdf_NLO->Scale(1./4); //hPP_cteq_NLO->Scale(1./4); //hPP_hera_NLO->Scale(1./4); hPPrebin->Scale(1e9); //hPPrebin->Scale(1./5300e6); //hPPrebin->Scale(1./4); //divideBinWidth(hPPrebin); hPPgen->Scale(1./4); hPPgen->Scale(1e9); fout.Write(); hPP_nnpdf_NLO = (TH1F*)hPP_nnpdf_NLO->Rebin(nbins_yaxian,"nnpdf_pp", boundaries_yaxian); hPP_nnpdf_NLO->Print("base"); hPP_cteq_NLO = (TH1F*)hPP_cteq_NLO->Rebin(nbins_yaxian,"cteq_pp", boundaries_yaxian); hPP_cteq_NLO->Print("base"); hPP_hera_NLO = (TH1F*)hPP_hera_NLO->Rebin(nbins_yaxian,"hera_pp", boundaries_yaxian); hPP_hera_NLO->Print("base"); hPP_ct10n_NLO = (TH1F*)hPP_ct10n_NLO->Rebin(nbins_yaxian,"ct10n_pp", boundaries_yaxian); hPP_ct10n_NLO->Print("base"); TH1F* hRatio_nnpdf_mc = (TH1F*)hPPgen->Rebin(nbins_yaxian,"hRatio_nnpdf_mc",boundaries_yaxian); hRatio_nnpdf_mc->Divide(hPP_nnpdf_NLO); TH1F* hRatio_cteq_mc = (TH1F*)hPPgen->Rebin(nbins_yaxian,"hRatio_cteq_mc",boundaries_yaxian); hRatio_cteq_mc->Divide(hPP_cteq_NLO); TH1F* hRatio_hera_mc = (TH1F*)hPPgen->Rebin(nbins_yaxian,"hRatio_hera_mc",boundaries_yaxian); hRatio_hera_mc->Divide(hPP_hera_NLO); TH1F* hRatio_ct10n_mc = (TH1F*)hPPgen->Rebin(nbins_yaxian,"hRatio_ct10n_mc",boundaries_yaxian); hRatio_ct10n_mc->Divide(hPP_ct10n_NLO); TH1F* hRatio_nnpdf = (TH1F*)hPP_nnpdf_NLO->Rebin(nbins_yaxian,"hRatio_nnpdf",boundaries_yaxian); hRatio_nnpdf->Divide(hPPrebin); TH1F* hRatio_cteq = (TH1F*)hPP_cteq_NLO->Rebin(nbins_yaxian,"hRatio_cteq",boundaries_yaxian); hRatio_cteq->Divide(hPPrebin); TH1F* hRatio_ct10n = (TH1F*)hPP_ct10n_NLO->Rebin(nbins_yaxian,"hRatio_ct10n",boundaries_yaxian); hRatio_ct10n->Divide(hPPrebin); TH1F* hRatio_hera = (TH1F*)hPP_hera_NLO->Rebin(nbins_yaxian,"hRatio_hera",boundaries_yaxian); hRatio_hera->Divide(hPPrebin); TH1F* hRatio_ppgen = (TH1F*)hPPgen->Rebin(nbins_yaxian,"hRatio_ppgen",boundaries_yaxian); hRatio_ppgen->Divide(hPPrebin); TH1F* hRatio_nnpdf_R_2_4 = (TH1F*)hPP_nnpdf_NLO_R2->Rebin(nbins_yaxian,"hRatio_nnpdf_R_2_4",boundaries_yaxian); hRatio_nnpdf_R_2_4->Divide(hPP_nnpdf_NLO_R4); TH1F* hRatio_nnpdf_R_3_4 = (TH1F*)hPP_nnpdf_NLO->Rebin(nbins_yaxian,"hRatio_nnpdf_R_3_4",boundaries_yaxian); hRatio_nnpdf_R_3_4->Divide(hPP_nnpdf_NLO_R4); TH1F* hRatio_cteq_R_2_4 = (TH1F*)hPP_cteq_NLO_R2->Rebin(nbins_yaxian,"hRatio_cteq_R_2_4",boundaries_yaxian); hRatio_cteq_R_2_4->Divide(hPP_cteq_NLO_R4); TH1F* hRatio_cteq_R_3_4 = (TH1F*)hPP_cteq_NLO->Rebin(nbins_yaxian,"hRatio_cteq_R_3_4",boundaries_yaxian); hRatio_cteq_R_3_4->Divide(hPP_cteq_NLO_R4); TH1F* hRatio_ct10n_R_2_4 = (TH1F*)hPP_ct10n_NLO_R2->Rebin(nbins_yaxian,"hRatio_ct10n_R_2_4",boundaries_yaxian); hRatio_ct10n_R_2_4->Divide(hPP_ct10n_NLO_R4); TH1F* hRatio_ct10n_R_3_4 = (TH1F*)hPP_ct10n_NLO->Rebin(nbins_yaxian,"hRatio_ct10n_R_3_4",boundaries_yaxian); hRatio_ct10n_R_3_4->Divide(hPP_ct10n_NLO_R4); TH1F* hRatio_hera_R_2_4 = (TH1F*)hPP_hera_NLO_R2->Rebin(nbins_yaxian,"hRatio_hera_R_2_4",boundaries_yaxian); hRatio_hera_R_2_4->Divide(hPP_hera_NLO_R4); TH1F* hRatio_hera_R_3_4 = (TH1F*)hPP_hera_NLO->Rebin(nbins_yaxian,"hRatio_hera_R_3_4",boundaries_yaxian); hRatio_hera_R_3_4->Divide(hPP_hera_NLO_R4); TH1F* hRatio_data_nnpdf_R_3 = (TH1F*)hPP_nnpdf_NLO->Rebin(nbins_yaxian,"hRatio_data_nnpdf_R_3",boundaries_yaxian); hRatio_data_nnpdf_R_3->Divide(hPP_data_R_3); TH1F* hRatio_data_nnpdf_R_4 = (TH1F*)hPP_nnpdf_NLO_R4->Rebin(nbins_yaxian,"hRatio_data_nnpdf_R_4",boundaries_yaxian); hRatio_data_nnpdf_R_4->Divide(hPP_data_R_4); TH1F* hRatio_data_R_3_4 = (TH1F*)hPP_data_R_3->Clone("hRatio_data_R_3_4"); hRatio_data_R_3_4->Divide(hPP_data_R_4); TH1F* hRatio_data_R_3_5 = (TH1F*)hPP_data_R_3->Clone("hRatio_data_R_3_5"); hRatio_data_R_3_5->Divide(hPP_data_R_5); TH1F* hRatio_data_R_4_5 = (TH1F*)hPP_data_R_4->Clone("hRatio_data_R_4_5"); hRatio_data_R_4_5->Divide(hPP_data_R_5); /* TCanvas *cnlo_mc = new TCanvas("cnlo_mc","",800,600); hRatio_nnpdf_mc->SetMarkerColor(kRed); hRatio_nnpdf_mc->SetMarkerStyle(20); hRatio_nnpdf_mc->SetXTitle("Jet p_{T} (GeV/c)"); hRatio_nnpdf_mc->SetYTitle("MC/NLO"); hRatio_nnpdf_mc->SetTitle(" "); hRatio_nnpdf_mc->SetAxisRange(0,1.5,"Y"); hRatio_nnpdf_mc->Draw(); hRatio_cteq_mc->SetMarkerColor(kBlue); hRatio_cteq_mc->SetMarkerStyle(20); hRatio_cteq_mc->Draw("same"); hRatio_ct10n_mc->SetMarkerColor(9); hRatio_ct10n_mc->SetMarkerStyle(20); hRatio_ct10n_mc->Draw("same"); hRatio_hera_mc->SetMarkerColor(kGreen); hRatio_hera_mc->SetMarkerStyle(20); hRatio_hera_mc->Draw("same"); TLegend *titlenlomc = myLegend(0.10,0.10,0.30,0.30); titlenlomc->AddEntry(hRatio_nnpdf_mc,"nnpdf","pl"); titlenlomc->AddEntry(hRatio_cteq_mc,"cteq","pl"); titlenlomc->AddEntry(hRatio_ct10n_mc,"ct10n","pl"); titlenlomc->AddEntry(hRatio_hera_mc,"hera","pl"); titlenlomc->SetTextSize(0.04); titlenlomc->Draw(); putCMSSim(0.1,0.92,0.06); drawText("pp #sqrt{s}=2.76(TeV)",0.65,0.92,16); drawText(Form("anti k_{T} R = 0.%d, NP corrections added to NLO",radius),0.15,0.83,16); cnlo_mc->SaveAs(Form("Ratio_mc_with_nlo_with_np_R%d.pdf",radius),"RECREATE"); */ TCanvas *c1 = new TCanvas("c1","",800,600); formatCanvas(c1); c1->cd(1); c1->cd(1)->SetLogy(); hPP_nnpdf_NLO->SetMarkerColor(kRed); hPP_nnpdf_NLO->SetMarkerStyle(33); hPP_cteq_NLO->SetMarkerColor(kBlue); hPP_cteq_NLO->SetMarkerStyle(33); hPP_ct10n_NLO->SetMarkerColor(9);//purple hPP_ct10n_NLO->SetMarkerStyle(33); hPP_hera_NLO->SetMarkerColor(kGreen); hPP_hera_NLO->SetMarkerStyle(33); hPPrebin->SetMarkerColor(kBlack); hPPrebin->SetMarkerStyle(8); hPPgen->SetMarkerColor(kOrange); hPPgen->SetMarkerStyle(8); //hPPgen->SetMarkerColor(kRed); //hPPgen->SetMarkerStyle(8); makeHistTitle(hPP_nnpdf_NLO,"","p_{T} (GeV/c)","#frac{d^{2} #sigma}{d p_{T} d #eta} (pb#frac{GeV}{c})"); //hPP_nnpdf_NLO->SetYTitle("#frac{d^{2} #sigma}{d p_{T} d #eta} (pb#frac{GeV}{c})"); //hPP_nnpdf_NLO->SetXTitle("p_{T} (GeV/c)"); hPP_nnpdf_NLO->SetAxisRange(22,500,"X"); hPP_nnpdf_NLO->SetTitle(" "); hPP_nnpdf_NLO->Draw("p"); hPP_cteq_NLO->Draw("same p"); hPP_ct10n_NLO->Draw("same p"); hPP_hera_NLO->Draw("same p"); hPPrebin->Draw("same p"); //hPPgen->Draw("same p"); TLegend * title = myLegend(0.47, 0.50,0.67, 0.8); title->AddEntry(hPP_nnpdf_NLO,"NLO nnpdf","pl"); title->AddEntry(hPP_cteq_NLO,"NLO cteq","pl"); title->AddEntry(hPP_ct10n_NLO,"NLO ct10n","pl"); title->AddEntry(hPP_hera_NLO,"NLO hera","pl"); //title->AddEntry(hPPgen,"pp MC spectra","pl"); title->AddEntry(hPPrebin,"pp unfolded 2013 data","pl"); title->SetTextSize(0.04); title->Draw(); putCMSPrel(0.1,0.92,0.06); drawText("pp 2013, #sqrt{s}=2.76(TeV), #int L dt = 5.3 (pb)^{-1}",0.35,0.92,16); drawText(Form("anti k_{T} R = 0.3, NP corrections added to NLO",radius),0.35,0.83,16); c1->cd(2); makeHistTitle(hRatio_nnpdf,"","p_{T} (GeV/c)","NLO / pp data"); //hRatio_nnpdf->SetYTitle(" X / pp data"); //hRatio_nnpdf->SetXTitle("p_{T} (GeV/c)"); hRatio_nnpdf->SetTitle(" "); hRatio_nnpdf->SetAxisRange(0.8,2,"Y"); hRatio_nnpdf->SetMarkerColor(kRed); hRatio_nnpdf->SetMarkerStyle(33); hRatio_hera->SetMarkerColor(kGreen); hRatio_hera->SetMarkerStyle(33); hRatio_cteq->SetMarkerColor(kBlue); hRatio_cteq->SetMarkerStyle(33); hRatio_ct10n->SetMarkerColor(9); hRatio_ct10n->SetMarkerStyle(33); hRatio_ppgen->SetMarkerColor(kOrange); hRatio_ppgen->SetMarkerStyle(33); hRatio_nnpdf->Draw("p"); hRatio_nnpdf->SetAxisRange(22,500,"X"); hRatio_hera->Draw("same p"); hRatio_cteq->Draw("same p"); hRatio_ct10n->Draw("same p"); //hRatio_ppgen->Draw("same p"); c1->SaveAs(Form("May22/pp_2760GeV_NLO_NPadded_ak%dPF_spectra.pdf",radius),"RECREATE"); /* //get the information from the ratio per bins - to use to scale down the NLO in 5.02 TeV. ofstream R_nnpdf,R_hera,R_cteq; R_nnpdf.open(Form("ratio_nnpdf_vs_pp_data_2760_ak%d.txt",radius)); R_hera.open(Form("ratio_hera_vs_pp_data_2760_ak%d.txt",radius)); R_cteq.open(Form("ratio_cteq_vs_pp_data_2760_ak%d.txt",radius)); for(int i = 0;i<hRatio_nnpdf->GetNbinsX();i++){ R_nnpdf<<i<<"\t"<<hRatio_nnpdf->GetBinContent(i)<<endl; R_hera<<i<<"\t"<<hRatio_hera->GetBinContent(i)<<endl; R_cteq<<i<<"\t"<<hRatio_cteq->GetBinContent(i)<<endl; } R_nnpdf.close(); R_hera.close(); R_cteq.close(); //draw the results for NLO comparison within different radius at the same energy TCanvas *c2 = new TCanvas("c2","",800,600); formatCanvas(c2); c2->cd(1); hPP_nnpdf_NLO->SetMarkerStyle(22); hPP_nnpdf_NLO->SetMarkerColor(3); hPP_nnpdf_NLO->Draw("p"); hPP_nnpdf_NLO_R2->SetMarkerStyle(22); hPP_nnpdf_NLO_R2->SetMarkerColor(2); hPP_nnpdf_NLO_R2->Draw("same p"); hPP_nnpdf_NLO_R4->SetMarkerStyle(22); hPP_nnpdf_NLO_R4->SetMarkerColor(4); hPP_nnpdf_NLO_R4->Draw("same p"); hPP_data_R_4->SetMarkerStyle(23); hPP_data_R_4->SetMarkerColor(4); hPP_data_R_4->Draw("same p"); hPP_data_R_3->SetMarkerStyle(23); hPP_data_R_3->SetMarkerColor(3); hPP_data_R_3->Draw("same p"); hPP_data_R_5->SetMarkerStyle(23); hPP_data_R_5->SetMarkerColor(9); hPP_data_R_5->Draw("same p"); TLegend * title2 = myLegend(0.47, 0.50,0.67, 0.8); title2->AddEntry(hPP_nnpdf_NLO_R2,"NNPDF21 R=0.2","pl"); title2->AddEntry(hPP_nnpdf_NLO,"NNPDF21 R=0.3","pl"); title2->AddEntry(hPP_nnpdf_NLO_R4,"NNPDF21 R=0.4","pl"); title2->AddEntry(hPP_data_R_3,"Data R=0.3","pl"); title2->AddEntry(hPP_data_R_4,"Data R=0.4","pl"); title2->AddEntry(hPP_data_R_5,"Data R=0.5","pl"); title2->SetTextSize(0.04); title2->Draw(); putCMSPrel(0.1,0.92,0.06); drawText("pp 2013, #sqrt{s}=2.76(TeV), #int L dt = 5.3 (pb)^{-1}",0.35,0.92,16); drawText(Form("anti k_{T}, Data vs Theory",radius),0.47,0.83,16); c2->cd(2); hRatio_nnpdf_R_2_4->SetMarkerStyle(29); hRatio_nnpdf_R_2_4->SetMarkerColor(2); hRatio_nnpdf_R_2_4->SetAxisRange(0.6,1.6,"Y"); hRatio_nnpdf_R_2_4->SetAxisRange(22,500,"X"); hRatio_nnpdf_R_2_4->SetTitle(" "); hRatio_nnpdf_R_2_4->SetYTitle("Ratios"); hRatio_nnpdf_R_2_4->SetXTitle("p_{T}(GeV/c)"); hRatio_nnpdf_R_2_4->Draw("p"); hRatio_nnpdf_R_3_4->SetMarkerStyle(29); hRatio_nnpdf_R_3_4->SetMarkerColor(3); hRatio_nnpdf_R_3_4->Draw("same p"); hRatio_data_nnpdf_R_3->SetMarkerStyle(33); hRatio_data_nnpdf_R_3->SetMarkerColor(4); hRatio_data_nnpdf_R_3->Draw("same p"); hRatio_data_nnpdf_R_4->SetMarkerStyle(33); hRatio_data_nnpdf_R_4->SetMarkerColor(7); hRatio_data_nnpdf_R_4->Draw("same p"); hRatio_data_R_3_4->SetMarkerStyle(34); hRatio_data_R_3_4->SetMarkerColor(6); hRatio_data_R_3_4->Draw("same p"); hRatio_data_R_3_5->SetMarkerStyle(34); hRatio_data_R_3_5->SetMarkerColor(7); hRatio_data_R_3_5->Draw("same p"); hRatio_data_R_4_5->SetMarkerStyle(34); hRatio_data_R_4_5->SetMarkerColor(8); hRatio_data_R_4_5->Draw("same p"); c2->cd(1); TLegend * title3 = myLegend(0.67, 0.40,0.77, 0.8); title3->AddEntry(hRatio_nnpdf_R_2_4,"NLO R=0.2/R=0.4","pl"); title3->AddEntry(hRatio_nnpdf_R_3_4,"NLO R=0.3/R=0.4","pl"); title3->AddEntry(hRatio_data_nnpdf_R_3,"R=0.3 NNPDF21/Data","pl"); title3->AddEntry(hRatio_data_nnpdf_R_4,"R=0.4 NNPDF21/Data","pl"); title3->AddEntry(hRatio_data_R_3_4,"Data R=0.3/R=0.4","pl"); title3->AddEntry(hRatio_data_R_3_5,"Data R=0.3/R=0.5","pl"); title3->AddEntry(hRatio_data_R_4_5,"Data R=0.4/R=0.5","pl"); title3->SetTextSize(0.04); title3->Draw(); c2->SaveAs("pp_2760GeV_data_NLO_NPCadded_radius_comparison.pdf","RECREATE"); fout.Write(); fout.Close(); */ /* TCanvas *c2 = new TCanvas("c2","",1000,800); c2->Divide(2,1); c2->cd(1); c2->cd(1)->SetLogy(); hPPunfo->SetTitle("PP 2013 2.76 TeV Merged, Unfolded p_{T} Spectra"); hPPunfo->SetYTitle("#frac{dN}{N_{MB} d p_{T} d #eta}"); hPPunfo->GetYaxis()->SetTitleOffset(1.4); hPPunfo->SetXTitle("Jet p_{T} GeV/c"); hPPunfo->GetXaxis()->SetRangeUser(50,500); hPPunfo->Draw(); hPPmeas->GetXaxis()->SetRangeUser(50,500); hPPmeas->SetMarkerStyle(22); hPPmeas->SetMarkerColor(kBlack); hPPmeas->Draw("same"); TLegend *titl = myLegend(0.54,0.65,0.85,0.9); titl->AddEntry(hPPmeas,"PP2013 Meas ak3PF","pl"); titl->AddEntry(hPPunfo,"PP2013 Unfo Bayesian","pl"); titl->SetTextSize(0.03); titl->Draw(); drawText("Anti-k_{T}PF R = 0.3",0.43,0.6,22); drawText("|#eta|<2, |vz|<15",0.47,0.5,22); c2->cd(2); TH1F* hPPRatio = (TH1F*)hPPmeas->Clone("hPPRatio"); hPPRatio->Divide(hPPunfo); hPPRatio->SetXTitle("Jet p_{T} GeV/c"); hPPRatio->SetYTitle("Ratio Measured/Unfolded"); hPPRatio->SetTitle("PP2013 ak3PF merged"); hPPRatio->GetYaxis()->SetRangeUser(0,2); hPPRatio->Draw(); c2->SaveAs("pp_2013_ak3_merged_unfolded_pt.pdf","RECREATE"); */ /* TH1F *hNLO_err = (TH1F*)fNLO->Get("h100203"); for(int i = 0;i<hNLO_err->GetNbinsX();i++){ Float_T valErr = hNLO_Err->GetBinError(i); hNLO->SetBinError(i,valErr); } */ /* //h100300 - ak4PF, h100200 - ak3PF TH1F* hNLO_2 = (TH1F*)hNLO->Clone("hNLO_2"); hNLO->Print("base"); TCanvas *cComp = new TCanvas("cComp","",800,600); cComp->Divide(2,1); cComp->cd(1); cComp->cd(1)->SetLogy(); hPPrebin->SetMarkerStyle(22); hPPrebin->SetMarkerColor(kRed); hNLO->SetMarkerStyle(20); hNLO->SetMarkerColor(kBlack); hNLO->SetTitle("PP 2.76 TeV"); hNLO->SetYTitle("#sigma pb"); hNLO->SetXTitle("Jet p_{T} GeV/c"); hNLO->Draw("pl"); hPPMCrebin->SetMarkerStyle(21); hPPMCrebin->SetMarkerColor(kBlue); hPPMCrebin->Draw("same"); hPPrebin->Draw("same"); TLegend *title = myLegend(0.34,0.65,0.54,0.75); title->AddEntry(hNLO,"NLO nnpdf21","pl"); title->AddEntry(hPPrebin,"PP ak3PF unfo","pl"); title->AddEntry(hPPMCrebin,"PP ak3PF MC Gen","pl"); title->SetTextSize(0.06); title->Draw(); cComp->cd(2); TH1F *hPP = (TH1F*)hPPrebin->Clone("hPP"); TH1F* hPPMC_v2 = (TH1F*)hPPMCrebin->Clone("hPPMC_v2"); hPP->Print("base"); hPPMC_v2->Print("base"); hPP->Divide(hNLO); hPPMC_v2->Divide(hNLO); hPP->SetTitle("Ratio of PP ak3PF unfolded and MC Gen to NLO"); //hPP->SetTitle("Ratio of PP ak4PF measured to NLO"); hPP->SetYTitle("#frac{#sigma_{PP}}{#sigma_{NLO}}"); hPP->SetXTitle("Jet p_{T} GeV/c"); hPP->Draw(); hPPMC_v2->Draw("same"); cComp->SaveAs("fastNLO_comparison/ratio_pp_ak3_merged_NLO_nnpdf21nlo.pdf","RECREATE"); TCanvas c1; c1.SetLogy(); hPPrebin->SetAxisRange(50,500,"X"); hPPrebin->SetYTitle("#sigma (pb)"); hPPrebin->SetXTitle("Jet p_{T} GeV/c"); hPPrebin->SetTitle("PP ak3PF unfolded"); hPPrebin->Draw(); c1.SaveAs("fastNLO_comparison/PP_2013_ak3_merged_Unfolded_crosssection.pdf","RECREATE"); c1.SaveAs("fastNLO_comparison/PP_2013_ak3_merged_Unfolded_crosssection.C","RECREATE"); TCanvas *c3 = new TCanvas("c3","",800,600); c3->SetGrid(); c3->SetLogy(); //TGraphErrors graph_Expected("./fastNLO_comparison/files/s2760_R0.3fine.tex","%lg %lg"); //graph_Expected.SetTitle("Non Perturbative corrections (extrapolation from Atlas) s2760;p_{T} GeV/c;#sigma nb"); //graph_Expected.DrawClone("E3AL"); TFile *fNPC = TFile::Open("fastNLO_comparison/files/npc_extrapolation_ivan.root"); TH1F* hNPC = (TH1F*)fNPC->Get("hNPC"); hNPC->Scale(1000);// 1000 for the pb from nb //hNPC->Print("base"); //TH1F* hNPC_rebin1 = rebin2(hNPC,"hNPC_rebin1"); //divideBinWidth(hNPC_rebin1); hNPC->SetTitle("Non Perturbative corrections (extrapolation from Atlas) s2760"); hNPC->SetXTitle("p_{T} GeV/c"); hNPC->SetYTitle("#sigma (pb)"); hNPC->Draw(); hPPrebin->Draw("same"); c3->SaveAs("fastNLO_comparison/NPC_atlas_ak3.pdf","RECREATE"); TCanvas *c4 = new TCanvas("c4","",800,600); c4->SetLogy(); //TH1F* hNPC_rebin = (TH1F*)hNPC->Clone("hNPC_rebin"); TH1F* hNPC_rebin = rebin2(hNPC,"hNPC_rebin"); divideBinWidth(hNPC_rebin); hPPrebin_2->SetTitle("PP Cross sections Data and Theory comparisons"); hPPrebin_2->SetYTitle("#sigma (pb)"); hPPrebin_2->SetXTitle("p_{T} GeV/c"); //hNPC_rebin->SetAxisRange(1e4,1e-2,"Y"); hPPrebin_2->SetMarkerStyle(23); hPPrebin_2->SetMarkerColor(kBlack); hPPrebin_2->SetAxisRange(50,450,"X"); hPPrebin_2->Draw("E"); //hPPrebin_2->SetAxisRange(50,450,"X"); hNPC_rebin->SetMarkerStyle(21); hNPC_rebin->SetMarkerColor(kRed); hNPC_rebin->Draw("same"); hNLO_2->SetMarkerStyle(25); hNLO_2->SetMarkerColor(kBlue); hNLO_2->Draw("same"); TLegend *title2 = myLegend(0.54,0.65,0.85,0.9); title2->AddEntry(hNPC_rebin,"Ivan NPC - Atlas R=0.3","pl"); title2->AddEntry(hPPrebin_2,"PP2013 ak3PF unfolded","pl"); title2->AddEntry(hNLO_2,"CMS NLO nnpdf21 R=0.3","l"); title2->SetTextSize(0.04); title2->Draw(); gStyle->SetOptStat(0); c4->SaveAs("fastNLO_comparison/pp_ak3_nlo_overlay_hist.pdf","RECREATE"); TCanvas *c6 = new TCanvas("c6","",800,600); TH1F* hPPratio = (TH1F*)hPPrebin_2->Clone("hPPratio"); //add the error bars directly before dividing them and then set that as the error. //FLoat_t delta_PP = 0; //Float_t delta_NPC = 0; //Float_t delta hPPratio->Divide(hNPC_rebin); hPPratio->SetTitle("Ratio of PP 2013 ak3 unfolded w/ Ivan's NPC Atlas"); hPPratio->SetYTitle(" "); hPPratio->SetXTitle("p_{T} GeV/c"); hPPratio->Draw(); c6->SaveAs("pp_ak3_npc_ratio.pdf","RECREATE"); TCanvas *c5 = new TCanvas("c5","",800,600); hNPC->Draw(); hNPC_rebin->Draw("same"); c5->SetLogy(); c5->SaveAs("Ivan_plot_rebin_ak3.pdf","RECREATE"); */ }
void macro_MakeFRClosureTest() { // parameters ////////////////////////////////////////////////////////////// // luminosity of data const float lumi = 10445; string inputFilePrefix = "invMassHistos"; // lumi and .root will be added //string inputFilePrefix = "test"; // plot data? const bool plotData = true; //const bool plotData = false; // which closure tests should be plotted? bool plotClosureTest[4]; plotClosureTest[0] = true; // no corrections plotClosureTest[1] = true; // GSF electrons not passing HEEP plotClosureTest[2] = true; // all above + HEEP-GSF corrected with DY contribuion plotClosureTest[3] = true; // all above + GSF-GSF corrected with W+jet and gamma+jet contribution // which histograms should be plotted? bool plotHisto[4]; plotHisto[0] = true; // EB-EB + EB-EE plotHisto[1] = true; // EB-EB plotHisto[2] = true; // EB-EE plotHisto[3] = true; // EE-EE int font = 42; //////////////////////////////////////////////////////////////////////////// const double yAxisMin = 0.001; // const int rebin = 10; float massMin = 50; float massMax = 2050; int nBins = 2000; vector<pair<float, float> > binning; // VARIABLE BINNING // binning.push_back(make_pair(100, 1)); // binning.push_back(make_pair(500, 10)); // binning.push_back(make_pair(massMax, 50)); // CONSTANT BINNING binning.push_back(make_pair(massMax, 10)); vector<float> bins; bins.push_back(massMin); for (vector<pair<float,float> >::iterator it = binning.begin(); it < binning.end(); ++it) { while (bins.back() < it->first) bins.push_back(bins.back() + it->second); } if (bins.back() < massMax) bins.push_back(massMax); nBins = bins.size() - 1; Double_t binArray[nBins + 1]; for (int i = 0; i <= nBins; ++i) binArray[i] = (Double_t)bins.at(i); stringstream sStream; sStream << "Photon_Run2012A-13Jul2012_06Aug2012+DoublePhotonHighPt_Run2012B-13Jul2012+DoublePhotonHighPt_Run2012C-PromptReco-v1+v2_Cert_190456-202016_8TeV_PromptReco_gct1_35_" << lumi << "pb-1"; //sStream << lumi << "pb-1"; TString folderDataHisto = sStream.str().c_str(); // select histograms dynamically depending on state of correction ////////// vector<TString> folderHeepGsfHisto; folderHeepGsfHisto.push_back(sStream.str().c_str()); folderHeepGsfHisto.push_back(sStream.str().c_str()); folderHeepGsfHisto.push_back("combinations"); folderHeepGsfHisto.push_back("combinations"); vector<TString> folderGsfGsfHisto; folderGsfGsfHisto.push_back(sStream.str().c_str()); folderGsfGsfHisto.push_back(sStream.str().c_str()); folderGsfGsfHisto.push_back(sStream.str().c_str()); folderGsfGsfHisto.push_back("combinations"); vector<TString> heepGsfHisto; heepGsfHisto.push_back("histoHeepGsfMassFR"); heepGsfHisto.push_back("histoHeepGsfMassNoHeepFR"); heepGsfHisto.push_back("histoHeepGsfCorr"); heepGsfHisto.push_back("histoHeepGsfCorr"); vector<TString> gsfGsfHisto; gsfGsfHisto.push_back("histoGsfGsfMassFR"); gsfGsfHisto.push_back("histoGsfGsfMassNoHeepFR"); gsfGsfHisto.push_back("histoGsfGsfMassNoHeepFR"); gsfGsfHisto.push_back("histoGsfGsfCorr"); //////////////////////////////////////////////////////////////////////////// vector<TString> canvasName; canvasName.push_back("closureFR"); canvasName.push_back("closureFRNoHeep"); canvasName.push_back("closureFRCorrDY"); canvasName.push_back("closureFRCorrFull"); vector<TString> canvasTitle; canvasTitle.push_back("Fake rate closure test uncorrected"); canvasTitle.push_back("Fake rate closure test GSF (non HEEP)"); canvasTitle.push_back("Fake rate closure test DY corrected"); canvasTitle.push_back("Fake rate closure test fully corrected"); vector<TString> legendHeepGsf; legendHeepGsf.push_back("HEEP-GSF uncorrected"); legendHeepGsf.push_back("HEEP-GSF(non HEEP)"); legendHeepGsf.push_back("HEEP-GSF DY corrected"); legendHeepGsf.push_back("HEEP-GSF DY corrected"); vector<TString> legendGsfGsf; legendGsfGsf.push_back("GSF-GSF uncorrected"); legendGsfGsf.push_back("GSF-GSF (non HEEP)"); legendGsfGsf.push_back("GSF-GSF (non HEEP)"); legendGsfGsf.push_back("GSF-GSF W+jet + \\gamma+jet corrected"); vector<TString> acroSuffix; acroSuffix.push_back(""); acroSuffix.push_back("BB"); acroSuffix.push_back("BE"); acroSuffix.push_back("EE"); vector<TString> suffix; suffix.push_back(""); suffix.push_back(" EB-EB"); suffix.push_back(" EB-EE"); suffix.push_back(" EE-EE"); sStream.str(""); sStream << inputFilePrefix << lumi << "pb-1.root"; TFile input(sStream.str().c_str(), "read"); input.cd(); cout << endl << "Input file: " << sStream.str() << endl; // to keep the histogram when the file is closed TH1::AddDirectory(kFALSE); TH1::SetDefaultSumw2(kTRUE); for (unsigned int j = 0; j < 4; ++j) { if (!plotClosureTest[j]) continue; for (unsigned int p = 0; p < 4; ++p) { if (!plotHisto[p]) continue; TCanvas *c0 = new TCanvas(canvasName[j] + acroSuffix[p], canvasTitle[j] + suffix[p], 100, 100, 800, 600); c0->cd(); c0->SetBorderMode(0); c0->SetFrameBorderMode(0); c0->SetFillColor(0); c0->SetFrameFillColor(0); c0->SetLogy(); gStyle->SetTitleFont(font); gStyle->SetLabelFont(font); gStyle->SetOptStat(0); gStyle->SetPadTickX(1); gStyle->SetPadTickY(1); // get the histograms input.cd(folderGsfGsfHisto[j]); TH1F *histoGsfGsf = (TH1F *)gDirectory->Get(gsfGsfHisto[j] + acroSuffix[p]); input.cd(folderHeepGsfHisto[j]); TH1F *histoHeepGsf = (TH1F *)gDirectory->Get(heepGsfHisto[j] + acroSuffix[p]); input.cd(folderDataHisto); TH1F *histoData = (TH1F *)gDirectory->Get("histoHeepHeepMass" + acroSuffix[p]); TH1F *histoGsfGsfRebinned = (TH1F *)histoGsfGsf->Rebin(nBins, gsfGsfHisto[j] + "Rebinned" + acroSuffix[p], binArray); TH1F *histoHeepGsfRebinned = (TH1F *)histoHeepGsf->Rebin(nBins, heepGsfHisto[j] + "Rebinned" + acroSuffix[p], binArray); TH1F *histoDataRebinned = (TH1F *)histoData->Rebin(nBins, "histoHeepHeepMassRebinned" + acroSuffix[p], binArray); histoGsfGsfRebinned->SetLineColor(4); histoGsfGsfRebinned->SetMarkerColor(4); histoGsfGsfRebinned->SetMarkerStyle(20); histoGsfGsfRebinned->SetTitleFont(font); histoHeepGsfRebinned->SetLineColor(2); histoHeepGsfRebinned->SetMarkerColor(2); histoHeepGsfRebinned->SetMarkerStyle(21); histoHeepGsfRebinned->SetTitleFont(font); histoHeepGsfRebinned->GetYaxis()->SetTitleFont(font); histoHeepGsfRebinned->GetYaxis()->SetLabelFont(font); histoHeepGsfRebinned->GetXaxis()->SetLabelFont(font); histoDataRebinned->SetLineColor(1); histoDataRebinned->SetMarkerColor(1); histoDataRebinned->SetMarkerStyle(20); histoDataRebinned->SetTitleFont(font); histoDataRebinned->GetYaxis()->SetTitleFont(font); histoDataRebinned->GetYaxis()->SetLabelFont(font); histoDataRebinned->GetXaxis()->SetLabelFont(font); sStream.str(""); if (binning.size() > 1) sStream << "# of events / bin"; else sStream << "# of events / " << binning.begin()->second << "GeV"; if (plotData) { histoDataRebinned->SetMinimum(yAxisMin); histoDataRebinned->SetTitle(canvasTitle[j] + suffix[p]); histoDataRebinned->GetYaxis()->SetTitle(sStream.str().c_str()); histoDataRebinned->Draw(); histoHeepGsfRebinned->Draw("sames"); } else { histoHeepGsfRebinned->SetTitle(canvasTitle[j] + suffix[p]); histoHeepGsfRebinned->GetYaxis()->SetTitle(sStream.str().c_str()); histoHeepGsfRebinned->Draw(); } histoGsfGsfRebinned->Draw("sames"); sStream.str(""); sStream << "#sqrt{s} = 8TeV, #int L dt = " << lumi << "pb^{-1}"; TPaveLabel *label0 = new TPaveLabel(0.6, 0.79, 0.9, 0.89, sStream.str().c_str(), "brNDC"); label0->SetFillColor(0); label0->SetFillStyle(0); label0->SetBorderSize(0); label0->SetTextSize(0.30); label0->SetTextFont(font); label0->Draw("sames"); TPaveLabel *label1 = new TPaveLabel(0.7, 0.89, 0.91, 0.98, "CMS preliminary", "brNDC"); label1->SetFillColor(0); label1->SetFillStyle(0); label1->SetBorderSize(0); label1->SetTextSize(0.40); label1->SetTextFont(font); label1->Draw("sames"); TLegend *legend = new TLegend(0.38, 0.6, 0.53, 0.9); if (!plotData) legend->SetY2(0.8); legend->SetTextSize(0.03); legend->SetTextFont(font); legend->SetBorderSize(0); legend->SetFillStyle(0); if (plotData) legend->AddEntry(histoDataRebinned, "Data", "lep"); legend->AddEntry(histoHeepGsfRebinned, legendHeepGsf[j], "lep"); legend->AddEntry(histoGsfGsfRebinned, legendGsfGsf[j], "lep"); legend->Draw("sames"); } // end loop over eta ranges } // end loop over corrections input.Close(); }
void comparisonJetMCData(string plot,int rebin){ string tmp; string dir="/gpfs/cms/data/2011/Observables/Approval/"; if (isAngularAnalysis){ mcfile=dir+"MC_zjets"+version; back_w=dir+"MC_wjets"+version; back_ttbar=dir+"MC_ttbar"+version; WW=dir+"MC_diW"+version; ZZ=dir+"MC_siZ"+version; WZ=dir+"MC_diWZ"+version; datafile=dir+"DATA"+version; mcfiletau=dir+"MC_zjetstau"+version; } // List of files TFile *dataf = TFile::Open(datafile.c_str()); //data file TFile *mcf = TFile::Open(mcfile.c_str()); //MC file TFile *mcftau = TFile::Open(mcfiletau.c_str()); //MC file TFile *ttbarf = TFile::Open(back_ttbar.c_str()); //MC background file TFile *wf = TFile::Open(back_w.c_str()); TFile *qcd23emf = TFile::Open(qcd23em.c_str()); TFile *qcd38emf = TFile::Open(qcd38em.c_str()); TFile *qcd817emf = TFile::Open(qcd817em.c_str()); TFile *qcd23bcf = TFile::Open(qcd23bc.c_str()); TFile *qcd38bcf = TFile::Open(qcd38bc.c_str()); TFile *qcd817bcf = TFile::Open(qcd817bc.c_str()); TFile *WZf = TFile::Open(WZ.c_str()); TFile *ZZf = TFile::Open(ZZ.c_str()); TFile *WWf = TFile::Open(WW.c_str()); // Canvas if (CanvPlot) delete CanvPlot; CanvPlot = new TCanvas("CanvPlot","CanvPlot",0,0,800,600); // Getting, defining ... dataf->cd("validationJEC"); if (isMu && isAngularAnalysis) dataf->cd("validationJECmu"); TObject * obj; gDirectory->GetObject(plot.c_str(),obj); TH1 *data; TH2F *data2; TH1D *data3; THStack *hs = new THStack("hs","Total MC"); int flag=-1; if ((data = dynamic_cast<TH1F *>(obj)) ){ flag=1; gROOT->Reset(); gROOT->ForceStyle(); gStyle->SetPadRightMargin(0.03); gPad->SetLogy(1); gPad->Modified(); gPad->Update(); } if ((data2 = dynamic_cast<TH2F *>(obj)) ){ flag=2; gStyle->SetPalette(1); gStyle->SetPadRightMargin(0.15); gPad->Modified(); } //=================== // Dirty jobs :) if (flag==1){ CanvPlot->cd(); TPad *pad1 = new TPad("pad1","pad1",0.01,0.33,0.99,0.99); pad1->Draw(); pad1->cd(); pad1->SetTopMargin(0.1); pad1->SetBottomMargin(0.01); pad1->SetRightMargin(0.1); pad1->SetFillStyle(0); pad1->SetLogy(1); TString str=data->GetTitle(); if (str.Contains("jet") && !str.Contains("zMass") && !str.Contains("Num") && !str.Contains("Eta") && !str.Contains("Phi") && !str.Contains("eld") && !str.Contains("meanPtZVsNjet")) { if (!isAngularAnalysis) rebin=1; } //====================== // DATA Double_t dataint = data->Integral(); data->SetLineColor(kBlack); data->Rebin(rebin); if(str.Contains("nJetVtx")) data->GetXaxis()->SetRangeUser(0,10); if(str.Contains("zMass")) data->GetXaxis()->SetRangeUser(70,110); data->SetMinimum(1.); data->Sumw2(); //Canvas style copied from plotsHistsRatio.C data->SetLabelSize(0.0); data->GetXaxis()->SetTitleSize(0.00); data->GetYaxis()->SetLabelSize(0.07); data->GetYaxis()->SetTitleSize(0.08); data->GetYaxis()->SetTitleOffset(0.76); data->SetTitle(""); gStyle->SetOptStat(0); data->GetYaxis()->SetLabelSize(0.06); data->GetYaxis()->SetTitleSize(0.06); data->GetYaxis()->SetTitleOffset(0.8); data->Draw("E1"); TLegend* legend = new TLegend(0.725,0.27,0.85,0.72); legend->SetFillColor(0); legend->SetFillStyle(0); legend->SetBorderSize(0); legend->SetTextSize(0.060); legend->AddEntry(data,"data","p"); // hack to calculate some yields in restricted regions... int num1=0, num2=0, num3=0, num4=0, num5=0; if(str.Contains("invMass") && !str.Contains("PF")){ for(int j=1;j<=data->GetNbinsX();j++){ num1 += data->GetBinContent(j); //conto quante Z ci sono tra 60 e 120 GeV if(j>10&&j<=50) num2 += data->GetBinContent(j); // ... tra 70 e 110 if(j>15&&j<=45) num3 += data->GetBinContent(j); // ... tra 75 e 105 } cout << "\n"; cout << data->GetNbinsX() <<" Number of bins of the invmass histo\n"; printf("Number of Z in 60-120 %i --- 70-110 %i --- 75-105 %i \n",num1,num2,num3); cout << "\n"; } if(str.Contains("zYieldVsjets") && !str.Contains("Vtx")){ for(int j=1;j<=data->GetNbinsX();j++){ num1 += data->GetBinContent(j); //conto quante Z if(j>1) num2 += data->GetBinContent(j); // ... +1,2,3,4... jets if(j>2) num3 += data->GetBinContent(j); // ... +2,3,4... jets if(j>3) num4 += data->GetBinContent(j); // .. if(str=="jet_pT"){ if(j>4) num5 += data->GetBinContent(j); // ... +4... jets } cout << "\n"; cout << data->GetNbinsX() <<" Number of bins of the zYieldVsjets histo\n"; printf("Number of Z+n jet %i --- >1 %i --- >2 %i --- >3 %i --- >4 %i \n",num1,num2,num3,num4,num5); cout << "\n"; } //====================== // Z + jets signal mcf->cd("validationJEC"); if (isMu) mcf->cd("validationJECmu/"); if (isAngularAnalysis) { mcf->cd("validationJEC/"); if (isMu) mcf->cd("validationJECmu/"); } TH1F* mc; gDirectory->GetObject(plot.c_str(),mc); TH1F * hsum; if(mc){ hsum = (TH1F*) mc->Clone(); hsum->SetTitle("hsum"); hsum->SetName("hsum"); hsum->Reset(); Double_t mcint = mc->Integral(); mc->SetFillColor(kRed); mc->Sumw2(); if(lumiweights==0) mc->Scale(dataint/mcint); // Blocco da propagare negli altri MC if(zNumEvents>0.){ if(lumiweights==1) { if (WholeStat){ if (lumiPixel) mc->Scale( dataLumi2011pix / (zNumEvents / zjetsXsect)); else mc->Scale( dataLumi2011 / (zNumEvents / zjetsXsect)); } else{ if (RunA){ if (lumiPixel) mc->Scale( dataLumi2011Apix / (zNumEvents / zjetsXsect)); else mc->Scale( dataLumi2011A / (zNumEvents / zjetsXsect)); } if (!RunA){ if (lumiPixel) mc->Scale( dataLumi2011Bpix / (zNumEvents / zjetsXsect)); else mc->Scale( dataLumi2011B / (zNumEvents / zjetsXsect)); } } } } else { if(lumiweights==1) mc->Scale(zjetsScale); } // fin qui if(lumiweights==1) mc->Scale(1./zwemean); // perche' i Weights non fanno 1... mc->Rebin(rebin); if(lumiweights==0) mc->Draw("HISTO SAMES"); hsum->Rebin(rebin); hsum->Add(mc); legend->AddEntry(mc,"Z+jets","f"); } //====================== // ttbar ttbarf->cd("validationJEC"); if (isMu) ttbarf->cd("validationJECmu/"); if (isAngularAnalysis) { ttbarf->cd("validationJEC/"); if (isMu) ttbarf->cd("validationJECmu/"); } TH1F* ttbar; gDirectory->GetObject(plot.c_str(),ttbar); if(ttbar){ ttbar->SetFillColor(kBlue); ttbar->Sumw2(); if(ttNumEvents>0.){ if(lumiweights==1) { if (WholeStat){ if (lumiPixel) ttbar->Scale( dataLumi2011pix / (ttNumEvents / ttbarXsect)); else ttbar->Scale( dataLumi2011 / (ttNumEvents / ttbarXsect)); } else{ if (RunA){ if (lumiPixel) ttbar->Scale( dataLumi2011Apix / (ttNumEvents / ttbarXsect)); else ttbar->Scale( dataLumi2011A / (ttNumEvents / ttbarXsect)); } if (!RunA){ if (lumiPixel) ttbar->Scale( dataLumi2011Bpix / (ttNumEvents / ttbarXsect)); else ttbar->Scale( dataLumi2011B / (ttNumEvents / ttbarXsect)); } } } } else { if(lumiweights==1) ttbar->Scale(ttwemean); } // fin qui if(lumiweights==1) ttbar->Scale(1./ttwemean); // perche' i Weights non fanno 1... ttbar->Rebin(rebin); if(lumiweights==0) ttbar->Draw("HISTO SAMES"); hsum->Rebin(rebin); hsum->Add(ttbar); if(lumiweights==1)legend->AddEntry(ttbar,"ttbar","f"); ////////// //Storing the bckgrounds! ////////// cout<<str<<endl; if (isAngularAnalysis){ if(str=="jet_pT") evaluateAndFillBackgrounds(ttbar,"jet_pT"); if(str=="jet_pT2") evaluateAndFillBackgrounds(ttbar,"jet_pT2"); if(str=="jet_pT3") evaluateAndFillBackgrounds(ttbar,"jet_pT3"); if(str=="jet_pT4") evaluateAndFillBackgrounds(ttbar,"jet_pT4"); if(str=="Jet_multi") evaluateAndFillBackgrounds(ttbar,"jet_Multiplicity"); if(str=="jet_eta") evaluateAndFillBackgrounds(ttbar,"jet_eta"); if(str=="jet_eta2") evaluateAndFillBackgrounds(ttbar,"jet_eta2"); if(str=="jet_eta3") evaluateAndFillBackgrounds(ttbar,"jet_eta3"); if(str=="jet_eta4") evaluateAndFillBackgrounds(ttbar,"jet_eta4"); if(str=="HT") evaluateAndFillBackgrounds(ttbar,"HT"); if(str=="HT_1j") evaluateAndFillBackgrounds(ttbar,"HT1"); if(str=="HT_2j") evaluateAndFillBackgrounds(ttbar,"HT2"); if(str=="HT_3j") evaluateAndFillBackgrounds(ttbar,"HT3"); if(str=="HT_4j") evaluateAndFillBackgrounds(ttbar,"HT4"); if(str=="Phi_star") evaluateAndFillBackgrounds(ttbar,"PhiStar"); } } //====================== // w+jets wf->cd("validationJEC"); if (isMu) wf->cd("validationJECmu/"); if (isAngularAnalysis) { wf->cd("validationJEC/"); if (isMu) wf->cd("validationJECmu/"); } TH1F* w; gDirectory->GetObject(plot.c_str(),w); if(w){ w->SetFillColor(kViolet+2); w->Sumw2(); if(wNumEvents>0.){ if(lumiweights==1) { if (WholeStat){ if (lumiPixel) w->Scale( dataLumi2011pix / (wNumEvents / wjetsXsect)); else w->Scale( dataLumi2011 / (wNumEvents / wjetsXsect)); } else{ if (RunA){ if (lumiPixel) w->Scale( dataLumi2011Apix / (wNumEvents / wjetsXsect)); else w->Scale( dataLumi2011A / (wNumEvents / wjetsXsect)); } if (!RunA){ if (lumiPixel) w->Scale( dataLumi2011Bpix / (wNumEvents / wjetsXsect)); else w->Scale( dataLumi2011B / (wNumEvents / wjetsXsect)); } } } } else { if(lumiweights==1) w->Scale(wwemean); } // fin qui if(lumiweights==1) w->Scale(1./wwemean); // perche' i Weights non fanno 1... w->Rebin(rebin); if(lumiweights==0) w->Draw("HISTO SAMES"); hsum->Rebin(rebin); hsum->Add(w); if(lumiweights==1)legend->AddEntry(w,"W+jets","f"); } //====================== // wz+jets WZf->cd("validationJEC"); if (isMu) WZf->cd("validationJECmu/"); if (isAngularAnalysis) { WZf->cd("validationJEC/"); if (isMu) WZf->cd("validationJECmu/"); } TH1F* wz; gDirectory->GetObject(plot.c_str(),wz); if(wz){ wz->SetFillColor(kYellow+2); wz->Sumw2(); if(wzEvents>0.){ if(lumiweights==1) { if (WholeStat){ if (lumiPixel) wz->Scale( dataLumi2011pix / (wzEvents / WZXsect)); else wz->Scale( dataLumi2011 / (wzEvents / WZXsect)); } else{ if (RunA){ if (lumiPixel) wz->Scale( dataLumi2011Apix / (wzEvents / WZXsect)); else wz->Scale( dataLumi2011A / (wzEvents / WZXsect)); } if (!RunA){ if (lumiPixel) wz->Scale( dataLumi2011Bpix / (wzEvents / WZXsect)); else wz->Scale( dataLumi2011B / (wzEvents / WZXsect)); } } } } else { if(lumiweights==1) wz->Scale(wzjetsScale); } // fin qui if(lumiweights==1) wz->Scale(1./wzwemean); // perche' i Weights non fanno 1... wz->Rebin(rebin); if(lumiweights==0) wz->Draw("HISTO SAMES"); hsum->Rebin(rebin); hsum->Add(wz); legend->AddEntry(wz,"WZ+jets","f"); ////////// //Storing the bckgrounds! ////////// if (isAngularAnalysis){ if(str=="jet_pT") evaluateAndFillBackgrounds(wz,"jet_pT"); if(str=="jet_pT2") evaluateAndFillBackgrounds(wz,"jet_pT2"); if(str=="jet_pT3") evaluateAndFillBackgrounds(wz,"jet_pT3"); if(str=="jet_pT4") evaluateAndFillBackgrounds(wz,"jet_pT4"); if(str=="jet_eta") evaluateAndFillBackgrounds(wz,"jet_eta"); if(str=="jet_eta2") evaluateAndFillBackgrounds(wz,"jet_eta2"); if(str=="jet_eta3") evaluateAndFillBackgrounds(wz,"jet_eta3"); if(str=="jet_eta4") evaluateAndFillBackgrounds(wz,"jet_eta4"); if(str=="Jet_multi") evaluateAndFillBackgrounds(wz,"jet_Multiplicity"); if(str=="HT") evaluateAndFillBackgrounds(wz,"HT"); if(str=="HT_1j") evaluateAndFillBackgrounds(wz,"HT1"); if(str=="HT_2j") evaluateAndFillBackgrounds(wz,"HT2"); if(str=="HT_3j") evaluateAndFillBackgrounds(wz,"HT3"); if(str=="HT_4j") evaluateAndFillBackgrounds(wz,"HT4"); if(str=="Phi_star") evaluateAndFillBackgrounds(wz,"PhiStar"); } } //====================== // zz+jets ZZf->cd("validationJEC"); if (isMu) ZZf->cd("validationJECmu/"); if (isAngularAnalysis) { ZZf->cd("validationJEC/"); if (isMu) ZZf->cd("validationJECmu/"); } TH1F* zz; gDirectory->GetObject(plot.c_str(),zz); if(zz){ zz->SetFillColor(kOrange+2); zz->Sumw2(); if(zzEvents>0.){ if(lumiweights==1) { if (WholeStat){ if (lumiPixel) zz->Scale( dataLumi2011pix / (zzEvents / ZZXsect)); else zz->Scale( dataLumi2011 / (zzEvents / ZZXsect)); } else{ if (RunA){ if (lumiPixel) zz->Scale( dataLumi2011Apix / (zzEvents / ZZXsect)); else zz->Scale( dataLumi2011A / (zzEvents / ZZXsect)); } if (!RunA){ if (lumiPixel) zz->Scale( dataLumi2011Bpix / (zzEvents / ZZXsect)); else zz->Scale( dataLumi2011B / (zzEvents / ZZXsect)); } } } } else { if(lumiweights==1) zz->Scale(zzjetsScale); } // fin qui if(lumiweights==1) zz->Scale(1./zzwemean); // perche' i Weights non fanno 1... zz->Rebin(rebin); if(lumiweights==0) zz->Draw("HISTO SAMES"); hsum->Rebin(rebin); hsum->Add(zz); legend->AddEntry(zz,"ZZ+jets","f"); ////////// //Storing the bckgrounds! ////////// if (isAngularAnalysis){ if(str=="jet_pT") evaluateAndFillBackgrounds(zz,"jet_pT"); if(str=="jet_pT2") evaluateAndFillBackgrounds(zz,"jet_pT2"); if(str=="jet_pT3") evaluateAndFillBackgrounds(zz,"jet_pT3"); if(str=="jet_pT4") evaluateAndFillBackgrounds(zz,"jet_pT4"); if(str=="jet_eta") evaluateAndFillBackgrounds(zz,"jet_eta"); if(str=="jet_eta2") evaluateAndFillBackgrounds(zz,"jet_eta2"); if(str=="jet_eta3") evaluateAndFillBackgrounds(zz,"jet_eta3"); if(str=="jet_eta4") evaluateAndFillBackgrounds(zz,"jet_eta4"); if(str=="Jet_multi") evaluateAndFillBackgrounds(zz,"jet_Multiplicity"); if(str=="HT") evaluateAndFillBackgrounds(zz,"HT"); if(str=="HT_1j") evaluateAndFillBackgrounds(zz,"HT1"); if(str=="HT_2j") evaluateAndFillBackgrounds(zz,"HT2"); if(str=="HT_3j") evaluateAndFillBackgrounds(zz,"HT3"); if(str=="HT_4j") evaluateAndFillBackgrounds(zz,"HT4"); if(str=="Phi_star") evaluateAndFillBackgrounds(zz,"PhiStar"); } } //====================== // ww+jets WWf->cd("validationJEC"); if (isMu) WWf->cd("validationJECmu/"); if (isAngularAnalysis) { WWf->cd("validationJEC/"); if (isMu) WWf->cd("validationJECmu/"); } TH1F* ww; gDirectory->GetObject(plot.c_str(),ww); if(ww){ ww->SetFillColor(kBlack); ww->Sumw2(); if(wwEvents>0.){ if(lumiweights==1) { if (WholeStat){ if (lumiPixel) ww->Scale( dataLumi2011pix / (wwEvents / WWXsect)); else ww->Scale( dataLumi2011 / (wwEvents / WWXsect)); } else{ if (RunA){ if (lumiPixel) ww->Scale( dataLumi2011Apix / (wwEvents / WWXsect)); else ww->Scale( dataLumi2011A / (wwEvents / WWXsect)); } if (!RunA){ if (lumiPixel) ww->Scale( dataLumi2011Bpix / (wwEvents / WWXsect)); else ww->Scale( dataLumi2011B / (wwEvents / WWXsect)); } } } } else { if(lumiweights==1) ww->Scale(wwjetsScale); } // fin qui if(lumiweights==1) ww->Scale(1./wwwemean); // perche' i Weights non fanno 1... ww->Rebin(rebin); if(lumiweights==0) ww->Draw("HISTO SAMES"); hsum->Rebin(rebin); hsum->Add(ww); legend->AddEntry(ww,"WW+jets","f"); ////////// //Storing the bckgrounds! ////////// if (isAngularAnalysis){ if(str=="jet_pT") evaluateAndFillBackgrounds(ww,"jet_pT"); if(str=="jet_pT2") evaluateAndFillBackgrounds(ww,"jet_pT2"); if(str=="jet_pT3") evaluateAndFillBackgrounds(ww,"jet_pT3"); if(str=="jet_pT4") evaluateAndFillBackgrounds(ww,"jet_pT4"); if(str=="jet_eta") evaluateAndFillBackgrounds(ww,"jet_eta"); if(str=="jet_eta2") evaluateAndFillBackgrounds(ww,"jet_eta2"); if(str=="jet_eta3") evaluateAndFillBackgrounds(ww,"jet_eta3"); if(str=="jet_eta4") evaluateAndFillBackgrounds(ww,"jet_eta4"); if(str=="Jet_multi") evaluateAndFillBackgrounds(ww,"jet_Multiplicity"); if(str=="HT") evaluateAndFillBackgrounds(ww,"HT"); if(str=="HT_1j") evaluateAndFillBackgrounds(ww,"HT1"); if(str=="HT_2j") evaluateAndFillBackgrounds(ww,"HT2"); if(str=="HT_3j") evaluateAndFillBackgrounds(ww,"HT3"); if(str=="HT_4j") evaluateAndFillBackgrounds(ww,"HT4"); if(str=="Phi_star") evaluateAndFillBackgrounds(ww,"PhiStar"); } } /// Tau //====================== mcftau->cd("validationJEC"); if (isMu) mcftau->cd("validationJECmu/"); if (isAngularAnalysis) { mcftau->cd("validationJEC/"); if (isMu) mcftau->cd("validationJECmu/"); } TH1F* tau; gDirectory->GetObject(plot.c_str(),tau); if(tau){ tau->SetFillColor(kGreen); tau->Sumw2(); if(zNumEvents>0.){ if(lumiweights==1) { if (WholeStat){ if (lumiPixel) tau->Scale( dataLumi2011pix / (zNumEvents / zjetsXsect)); else tau->Scale( dataLumi2011 / (zNumEvents / zjetsXsect)); } else{ if (RunA){ if (lumiPixel) tau->Scale( dataLumi2011Apix / (zNumEvents / zjetsXsect)); else tau->Scale( dataLumi2011A / (zNumEvents / zjetsXsect)); } if (!RunA){ if (lumiPixel) tau->Scale( dataLumi2011Bpix / (zNumEvents / zjetsXsect)); else tau->Scale( dataLumi2011B / (zNumEvents / zjetsXsect)); } } } } else { if(lumiweights==1) tau->Scale(zjetsScale); } // fin qui if(lumiweights==1) tau->Scale(1./zwemean); // perche' i Weights non fanno 1... tau->Rebin(rebin); if(lumiweights==0) tau->Draw("HISTO SAMES"); hsum->Rebin(rebin); tau->Scale(1./1000.); //aaaaaaa hsum->Add(tau); legend->AddEntry(tau,"#tau#tau+jets","f"); ////////// //Storing the bckgrounds! ////////// if (isAngularAnalysis){ if(str=="jet_pT") evaluateAndFillBackgrounds(tau,"jet_pT"); if(str=="jet_pT2") evaluateAndFillBackgrounds(tau,"jet_pT2"); if(str=="jet_pT3") evaluateAndFillBackgrounds(tau,"jet_pT3"); if(str=="jet_pT4") evaluateAndFillBackgrounds(tau,"jet_pT4"); if(str=="jet_eta") evaluateAndFillBackgrounds(tau,"jet_eta"); if(str=="jet_eta2") evaluateAndFillBackgrounds(tau,"jet_eta2"); if(str=="jet_eta3") evaluateAndFillBackgrounds(tau,"jet_eta3"); if(str=="jet_eta4") evaluateAndFillBackgrounds(tau,"jet_eta4"); if(str=="Jet_multi") evaluateAndFillBackgrounds(tau,"jet_Multiplicity"); if(str=="HT") evaluateAndFillBackgrounds(tau,"HT"); if(str=="HT_1j") evaluateAndFillBackgrounds(tau,"HT1"); if(str=="HT_2j") evaluateAndFillBackgrounds(tau,"HT2"); if(str=="HT_3j") evaluateAndFillBackgrounds(tau,"HT3"); if(str=="HT_4j") evaluateAndFillBackgrounds(tau,"HT4"); if(str=="Phi_star") evaluateAndFillBackgrounds(tau,"PhiStar"); } } ///////// // Print the bkg contributions //////// for(int j=0;j<bckg_leadingJetPt.size();j++){ cout<<bckg_leadingJetPt[j]<<endl; } //====================== // QCD EM enriched qcd23emf->cd("validationJEC"); TH1F* qcd23emp; gDirectory->GetObject(plot.c_str(),qcd23emp); if(qcd23emp){ TH1D * qcdTotEM = (TH1D*) qcd23emp->Clone(); qcdTotEM->SetTitle("qcd em"); qcdTotEM->SetName("qcd em"); qcdTotEM->Reset(); qcdTotEM->Rebin(rebin); qcd38emf->cd("validationJEC"); TH1F* qcd38emp; gDirectory->GetObject(plot.c_str(),qcd38emp); qcd817emf->cd("validationJEC"); TH1F* qcd817emp; gDirectory->GetObject(plot.c_str(),qcd817emp); qcd23emp->Rebin(rebin); qcd23emp->Sumw2(); qcd23emp->Scale(qcd23emScale); qcd38emp->Rebin(rebin); qcd38emp->Sumw2(); qcd38emp->Scale(qcd38emScale); qcd817emp->Rebin(rebin); qcd817emp->Sumw2(); qcd817emp->Scale(qcd817emScale); qcdTotEM->SetFillColor(kOrange+1); qcdTotEM->Add(qcd23emp); qcdTotEM->Add(qcd38emp); qcdTotEM->Add(qcd817emp); hsum->Add(qcdTotEM); //if(lumiweights==1)legend->AddEntry(qcdTotEM,"QCD em","f"); } //====================== // QCD bc qcd23bcf->cd("validationJEC"); TH1F* qcd23bcp; TH1D * qcdTotBC; bool qcdbcempty=true; gDirectory->GetObject(plot.c_str(),qcd23bcp); if(qcd23bcp){ qcdTotBC = (TH1D*) qcd23bcp->Clone(); qcdTotBC->SetTitle("qcd bc"); qcdTotBC->SetName("qcd bc"); qcdTotBC->Reset(); qcdTotBC->Rebin(rebin); qcd38bcf->cd("validationJEC"); TH1F* qcd38bcp; gDirectory->GetObject(plot.c_str(),qcd38bcp); qcd817bcf->cd("validationJEC"); TH1F* qcd817bcp; gDirectory->GetObject(plot.c_str(),qcd817bcp); qcd23bcp->Rebin(rebin); qcd23bcp->Sumw2(); qcd23bcp->Scale(qcd23bcScale); qcd38bcp->Rebin(rebin); qcd38bcp->Sumw2(); qcd38bcp->Scale(qcd38bcScale); qcd817bcp->Rebin(rebin); qcd817bcp->Sumw2(); qcd817bcp->Scale(qcd817bcScale); qcdTotBC->SetFillColor(kGreen+2); qcdTotBC->Add(qcd23bcp); qcdTotBC->Add(qcd38bcp); qcdTotBC->Add(qcd817bcp); hsum->Add(qcdTotBC); if (qcdTotBC->GetEntries()>0) qcdbcempty=false; //if(lumiweights==1)legend->AddEntry(qcdTotBC,"QCD bc","f"); } //====================== // Add here other backgrounds //====================== // Stacked Histogram //if(qcd23em) hs->Add(qcdTotEM); if(!qcdbcempty) hs->Add(qcdTotBC); if(w) hs->Add(w); if (ww) hs->Add(ww); if(tau) hs->Add(tau); //Z+Jets if (zz) hs->Add(zz); if (wz) hs->Add(wz); if (ttbar) hs->Add(ttbar); if(mc) hs->Add(mc); //Z+Jets // per avere le statistiche if(lumiweights==1) hsum->Draw("HISTO SAME"); //====================== // Setting the stats //pad1->Update(); // altrimenti non becchi la stat //TPaveStats *r2; //if(lumiweights==0) r2 = (TPaveStats*)mc->FindObject("stats"); //if(lumiweights==1) r2 = (TPaveStats*)hsum->FindObject("stats"); //r2->SetY1NDC(0.875); //Uncomment if you wonna add your statistics in the top right corner //r2->SetY2NDC(0.75); //r2->SetTextColor(kRed); if(lumiweights==1) hs->Draw("HISTO SAME"); gPad->RedrawAxis(); data->Draw("E1 SAME"); //r2->Draw(); //here to reactivate the stats legend->Draw(); TLegend* lumi = new TLegend(0.45,0.3,0.75,0.2); lumi->SetFillColor(0); lumi->SetFillStyle(0); lumi->SetBorderSize(0); //lumi->AddEntry((TObject*)0,"#int L dt =4.9 1/fb",""); lumi->Draw(); string channel; if (isMu) channel="Z#rightarrow#mu#mu"; if (!isMu) channel="Z#rightarrow ee"; TLatex *latexLabel=CMSPrel(4.890,channel,0.55,0.85); // make fancy label latexLabel->Draw("same"); CanvPlot->Update(); //===============// // RATIO DATA MC // //===============// CanvPlot->cd(); TPad *pad2 = new TPad("pad2","pad2",0.01,0.01,0.99,0.32); pad2->Draw(); pad2->cd(); pad2->SetTopMargin(0.01); pad2->SetBottomMargin(0.3); pad2->SetRightMargin(0.1); pad2->SetFillStyle(0); TH1D * ratio = (TH1D*) data->Clone(); ratio->SetTitle(""); ratio->SetName("ratio"); ratio->Reset(); ratio->Sumw2(); //data->Sumw2(); hsum->Sumw2(); // FIXME controlla che sia corretto questo... ratio->SetMarkerSize(.5); ratio->SetLineColor(kBlack); ratio->SetMarkerColor(kBlack); //gStyle->SetOptStat("m"); TH1F* sumMC; hs->Draw("nostack"); sumMC=(TH1F*) hs->GetHistogram(); cout<<sumMC->GetEntries()<<endl; ratio->Divide(data,hsum,1.,1.); ratio->GetYaxis()->SetRangeUser(0.5,1.5); ratio->SetMarkerSize(0.8); //pad2->SetTopMargin(1); //Canvas style copied from plotsHistsRatio.C ratio->GetYaxis()->SetNdivisions(5); ratio->GetXaxis()->SetTitleSize(0.14); ratio->GetXaxis()->SetLabelSize(0.14); ratio->GetYaxis()->SetLabelSize(0.11); ratio->GetYaxis()->SetTitleSize(0.11); ratio->GetYaxis()->SetTitleOffset(0.43); ratio->GetYaxis()->SetTitle("ratio data/MC"); ratio->Draw("E1"); TLine *OLine = new TLine(ratio->GetXaxis()->GetXmin(),1.,ratio->GetXaxis()->GetXmax(),1.); OLine->SetLineColor(kBlack); OLine->SetLineStyle(2); OLine->Draw(); TLegend* label = new TLegend(0.60,0.9,0.50,0.95); label->SetFillColor(0); label->SetFillStyle(0); label->SetBorderSize(0); //horrible mess double binContent = 0; double binSum = 0; double weightSum = 0; double binError = 1; double totalbins = ratio->GetSize() -2; for(unsigned int bin=1;bin<=totalbins;bin++){ binContent = ratio->GetBinContent(bin); binError = ratio->GetBinError(bin); if(binError!=0){ binSum += binContent/binError; weightSum += 1./binError; } } double ymean = binSum / weightSum; //double ymean = ratio->GetMean(2); stringstream sYmean; sYmean << ymean; string labeltext=sYmean.str()+" mean Y"; //label->AddEntry((TObject*)0,labeltext.c_str(),""); // mean on Y //label->Draw(); //TPaveStats *r3 = (TPaveStats*)ratio->FindObject("stats"); //r3->SetX1NDC(0.01); //r3->SetX2NDC(0.10); //r3->SetY1NDC(0.20); //r3->SetY2NDC(0.50); //gStyle->SetOptStat("mr"); //r3->SetTextColor(kWhite); //r3->SetLineColor(kWhite); //r3->Draw(); CanvPlot->Update(); tmp=plotpath+plot+".png"; CanvPlot->Print(tmp.c_str()); } else if (flag==2){ //CanvPlot.Divide(2,1); //CanvPlot.cd(1); // data dataf->cd("validationJEC"); if (isMu && isAngularAnalysis) dataf->cd("validationJECmu"); gDirectory->GetObject(plot.c_str(),data2); data2->Draw("COLZ"); gPad->Update(); // altrimenti non becchi la stat TPaveStats *r1 = (TPaveStats*)data2->FindObject("stats"); //r1->SetX1NDC(0.70); Uncomment if you wonna draw your stat in the top right corner //r1->SetX2NDC(0.85); //r1->Draw(); CanvPlot->Update(); tmp=plotpath+plot+"data.png"; CanvPlot->Print(tmp.c_str()); //CanvPlot.cd(2); // montecarlo mcf->cd("validationJEC"); if (isMu) mcf->cd("validationJECmu/"); if (isAngularAnalysis) { mcf->cd("validationJEC/"); if (isMu) mcf->cd("validationJECmu/"); } gDirectory->GetObject(plot.c_str(),data2); data2->SetMinimum(1); data2->Draw("COLZ"); gPad->Update(); // altrimenti non becchi la stat //TPaveStats *r2 = (TPaveStats*)data2->FindObject("stats"); //r2->SetX1NDC(0.70); //r2->SetX2NDC(0.85); //r2->Draw(); CanvPlot->Update(); tmp=plotpath+plot+"mc.png"; CanvPlot->Print(tmp.c_str()); } // else { cout << "You're getting an exception! Most likely there's no histogram here... \n"; } delete data; delete data2; delete hs; //delete CanvPlot; dataf->Close(); mcf->Close(); ttbarf->Close(); wf->Close(); qcd23emf->Close(); qcd38emf->Close(); qcd817emf->Close(); qcd23bcf->Close(); qcd38bcf->Close(); qcd817bcf->Close(); WZf->Close(); ZZf->Close(); if (isAngularAnalysis){ if (bckg_leadingJetPt.size()>0 && bckg_2leadingJetPt.size()>0 && bckg_3leadingJetPt.size()>0 && bckg_4leadingJetPt.size()>0 && bckg_JetMultiplicity.size()>0 && bckg_HT.size()>0 && bckg_leadingJetEta.size()>0 && bckg_PhiStar.size()>0 && cold){ fzj->cd(); treeBKG_->Fill(); treeBKG_->Write(); TH1F *leadhisto=new TH1F("leadhisto","leading jet background contribution",bckg_leadingJetPt.size(),0,bckg_leadingJetPt.size()); TH1F *leadhisto2=new TH1F("leadhisto2","subleading jet background contribution",bckg_leadingJetPt.size(),0,bckg_leadingJetPt.size()); TH1F *leadhisto3=new TH1F("leadhisto3","subsubleading jet background contribution",bckg_leadingJetPt.size(),0,bckg_leadingJetPt.size()); TH1F *leadhisto4=new TH1F("leadhisto4","subsubsubleading jet background contribution",bckg_leadingJetPt.size(),0,bckg_leadingJetPt.size()); TH1F *multiphisto=new TH1F("multiphisto","jet multiplicity background contribution",bckg_JetMultiplicity.size(),0,bckg_JetMultiplicity.size()); TH1F *HT=new TH1F("HT","HT background contribution",bckg_HT.size(),0,bckg_HT.size()); TH1F *HT1=new TH1F("HT1","HT background contribution when >= 1 jet",bckg_HT1.size(),0,bckg_HT1.size()); TH1F *HT2=new TH1F("HT2","HT background contribution when >= 2 jets",bckg_HT2.size(),0,bckg_HT2.size()); TH1F *HT3=new TH1F("HT3","HT background contribution when >= 3 jets",bckg_HT3.size(),0,bckg_HT3.size()); TH1F *HT4=new TH1F("HT4","HT background contribution when >= 4 jets",bckg_HT4.size(),0,bckg_HT4.size()); TH1F *leadhistoeta=new TH1F("leadhistoeta","leading jet background contribution",bckg_leadingJetEta.size(),0,bckg_leadingJetEta.size()); TH1F *leadhistoeta2=new TH1F("leadhistoeta2","subleading jet background contribution",bckg_leadingJetEta.size(),0,bckg_leadingJetEta.size()); TH1F *leadhistoeta3=new TH1F("leadhistoeta3","subsubleading jet background contribution",bckg_leadingJetEta.size(),0,bckg_leadingJetEta.size()); TH1F *leadhistoeta4=new TH1F("leadhistoeta4","subsubsubleading jet background contribution",bckg_leadingJetEta.size(),0,bckg_leadingJetEta.size()); TH1F *PhiStar=new TH1F("PhiStar","PhiStar background contribution",bckg_PhiStar.size(),0,bckg_PhiStar.size()); for (int i=0; i< bckg_leadingJetPt.size(); i++){ leadhisto->Fill(i,bckg_leadingJetPt[i]); leadhisto2->Fill(i,bckg_2leadingJetPt[i]); leadhisto3->Fill(i,bckg_3leadingJetPt[i]); leadhisto4->Fill(i,bckg_4leadingJetPt[i]); } leadhisto->Write(); leadhisto2->Write(); leadhisto3->Write(); leadhisto4->Write(); for (int i=0; i< bckg_leadingJetEta.size(); i++){ leadhistoeta->Fill(i,bckg_leadingJetEta[i]); leadhistoeta2->Fill(i,bckg_2leadingJetEta[i]); leadhistoeta3->Fill(i,bckg_3leadingJetEta[i]); leadhistoeta4->Fill(i,bckg_4leadingJetEta[i]); } leadhistoeta->Write(); leadhistoeta2->Write(); leadhistoeta3->Write(); leadhistoeta4->Write(); //fzj->Close(); for (int i=0; i< bckg_JetMultiplicity.size(); i++){ multiphisto->Fill(i,bckg_JetMultiplicity[i]); } multiphisto->Write(); /////////////// for (int i=0; i< bckg_HT.size(); i++){ HT->Fill(i,bckg_HT[i]); } HT->Write(); for (int i=0; i< bckg_HT1.size(); i++){ HT1->Fill(i,bckg_HT1[i]); } HT1->Write(); for (int i=0; i< bckg_HT2.size(); i++){ HT2->Fill(i,bckg_HT2[i]); } HT2->Write(); for (int i=0; i< bckg_HT3.size(); i++){ HT3->Fill(i,bckg_HT3[i]); } HT3->Write(); for (int i=0; i< bckg_HT4.size(); i++){ HT4->Fill(i,bckg_HT4[i]); } HT4->Write(); //Phi star for (int i=0; i< bckg_PhiStar.size(); i++){ PhiStar->Fill(i,bckg_PhiStar[i]); } PhiStar->Write(); cold=false; } } return; }
void make_overlay() { float lumi=1000.; vector <string > namelist; vector <string > plotlist; vector <TFile* > data; vector <TFile* > filelist; vector<float> nEvtTot; vector<float> McXsec; vector<float> DataLumi; //file 0-3 are the files to fit filelist.push_back(TFile::Open("/cms/data24/clseitz/MC_4_2_4/TTbarJets_pileup/TTbarJets_LeptonANA_full_e25_met30_b12.root")); namelist.push_back("TTbarJEts"); //nEvtTot.push_back(216095.0); nEvtTot.push_back(3701936.0); McXsec.push_back(157); DataLumi.push_back(lumi); filelist.push_back(TFile::Open("/cms/data24/clseitz/MC_4_2_4/Wprime2/Wp1000_CMS_LeptonANA_e25_met30_b12.root")); namelist.push_back("Wp1000"); nEvtTot.push_back(99995.0); McXsec.push_back(0.72); DataLumi.push_back(lumi); filelist.push_back(TFile::Open("/cms/data24/clseitz/MC_4_2_4/Wprime2/Wp600_CMS_LeptonANA_e25_met30_b12.root")); namelist.push_back("Wp600"); nEvtTot.push_back(99987.0); McXsec.push_back(8.0); DataLumi.push_back(lumi); //filelist.push_back(TFile::Open("/cms/data24/clseitz/MC_4_2_4/Sbottom/Sbottom750_neutralino150_LeptonAna_e25_met30_b12.root")); filelist.push_back(TFile::Open("/home/clseitz/MyCMS/CMSSW_4_2_4/src/TopBSM/TopXana/submit/test.root")); namelist.push_back("Sbottom"); nEvtTot.push_back(7800.0); McXsec.push_back(8.0); DataLumi.push_back(lumi); filelist.push_back(TFile::Open("/cms/data21/clseitz/CMS_leptons/Electrons/NewCode4/Electrons_full_900_emu_met50_b1.root")); namelist.push_back("electron"); nEvtTot.push_back(1.0); McXsec.push_back(1.0); DataLumi.push_back(1.0); //plotlist.push_back("Event/SumptSig4HighestPlus"); //plotlist.push_back("Event/SumptSig4SecondHighestPlus"); //plotlist.push_back("Event/TransMassLepMET4JetPlus"); //plotlist.push_back("Event/TransMassLepMET4SecondJetPlus"); //plotlist.push_back("Event/SumptSig4HighestMinus"); //plotlist.push_back("Event/SumptSig4SecondHighestMinus"); //plotlist.push_back("Event/TransMassLepMET4JetMinus"); //plotlist.push_back("Event/TransMassLepMET4SecondJetMinus"); plotlist.push_back("Event/TransMassLepMET4JetPlus_5jet1b"); plotlist.push_back("Event/TransMassLepMET4JetPlus_5jet2b"); plotlist.push_back("Event/TransMassLepMET4JetPlus_4jet1b"); plotlist.push_back("Event/TransMassLepMET4JetPlus_4jet2b"); plotlist.push_back("Event/TransMassLepMET4JetMinus_5jet1b"); plotlist.push_back("Event/TransMassLepMET4JetMinus_5jet2b"); plotlist.push_back("Event/TransMassLepMET4JetMinus_4jet1b"); plotlist.push_back("Event/TransMassLepMET4JetMinus_4jet2b"); TFile fnew1("overlay_plots.root", "recreate"); for(int i=0; i<4; i++){ TCanvas* c1= new TCanvas((plotlist[i].c_str()),(plotlist[i].c_str()),800,600); TH1F* dummy; dummy = new TH1F("","",1000,0,2000); //if(i==0 || i==1 || i==4 || i==5) dummy = new TH1F("","",100,0,2); //if(i==2 || i==3 || i==6 || i ==7) dummy = new TH1F("","",1000,0,2000); dummy->GetYaxis()->SetRangeUser(0.1,200); //c1->SetLogy(); //c1->SetGridx(); //c1->SetGridy(); dummy->SetTitle(plotlist[i].c_str()); dummy->Draw(); TLegend *leg = new TLegend(0.7060302,0.7692308,0.9761307,0.972028,NULL,"brNDC"); for(int file=0; file<4; file++){ std::stringstream dir; cout<<namelist[file]<<endl; dir<<namelist[file]; TH1F* temp; TH1F* tempa; TH1F* tempb; tempa = (TH1F*) filelist[file]->Get(plotlist[i].c_str()); temp = (TH1F*) tempa->Rebin(10, "temp"); TH1F* temp2; tempb = (TH1F*) filelist[file]->Get(plotlist[i+4].c_str()); temp2 = (TH1F*) tempb->Rebin(10,"temp2"); temp->Add(temp2); float scale = (1.0/nEvtTot[file])*DataLumi[file]*McXsec[file]; temp->Scale(scale); c1->cd(); temp->Draw("SAME"); temp->SetLineColor(file+1); if(file==4){ temp->Sumw2(); temp->SetMarkerStyle(23); temp->SetLineColor(12); } leg->AddEntry(temp, namelist[file].c_str(),"lep"); } c1->cd(); leg->Draw(); fnew1.cd(); c1->Write(); std::stringstream gif; gif<<plotlist[i]<<".gif"; c1->SaveAs((gif.str()).c_str()); // temp_Mjj->Wr } }