TH1D* createCorrelationPlot(TH2D* numerator2D, TH1D* denominator1D) { TH1::SetDefaultSumw2(); normaliseHist(denominator1D); std::vector<double> massBins = generate4Bins(); TH2D* denominator2D = create2Dfrom1D(massBins, denominator1D); normaliseHist(numerator2D); TH2D* corr2D = (TH2D*) numerator2D->Clone(); corr2D->Divide(denominator2D); int nBinsX = massBins.size()-1; int nUniqueBins = (nBinsX+1)*nBinsX/2.; TH1D* corr1D = unique1DBinsFrom2D(corr2D, nUniqueBins); setCorrTitlesMaxMin(corr1D); return corr1D; }
//___________________________________________________________________ Int_t studyBinZero(TString pathData, TString fileNameData, TString listName = "", Double_t etaLow = -0.9, Double_t etaUp = 0.9, Double_t lowerCentrality = -2, Double_t upperCentrality = -2) { PrintSettingsAxisRangeForMultiplicityAxisForMB(); TString pathNameData = Form("%s/%s", pathData.Data(), fileNameData.Data()); if (listName == "") { listName = pathNameData; listName.Replace(0, listName.Last('/') + 1, ""); listName.ReplaceAll(".root", ""); } TObjArray* histList = 0x0; TFile* f = TFile::Open(pathNameData.Data()); if (!f) { std::cout << std::endl; std::cout << "Failed to open file \"" << pathNameData.Data() << "\"!" << std::endl; return -1; } histList = (TObjArray*)(f->Get(listName.Data())); if (!histList) { std::cout << std::endl; std::cout << "Failed to load list \"" << listName.Data() << "\"!" << std::endl; return -1; } // Extract the data histograms TH1* hNumEventsTriggerSel = dynamic_cast<TH1*>(histList->FindObject("fhEventsTriggerSel")); TH1* hNumEventsTriggerSelVtxCut = dynamic_cast<TH1*>(histList->FindObject("fhEventsTriggerSelVtxCut")); TH1* hNumEventsTriggerSelVtxCutZ= dynamic_cast<TH1*>(histList->FindObject("fhEventsProcessedNoPileUpRejection")); TH1* hNumEventsTriggerSelVtxCutZPileUpRej= dynamic_cast<TH1*>(histList->FindObject("fhEventsProcessed")); THnSparse* hDataTriggerSel = dynamic_cast<THnSparse*>(histList->FindObject("fChargedGenPrimariesTriggerSel")); THnSparse* hDataTriggerSelVtxCut = dynamic_cast<THnSparse*>(histList->FindObject("fChargedGenPrimariesTriggerSelVtxCut")); THnSparse* hDataTriggerSelVtxCutZ = dynamic_cast<THnSparse*>(histList->FindObject("fChargedGenPrimariesTriggerSelVtxCutZ")); THnSparse* hDataTriggerSelVtxCutZPileUpRej = dynamic_cast<THnSparse*>(histList->FindObject("fChargedGenPrimariesTriggerSelVtxCutZPileUpRej")); setSparseErrors(hDataTriggerSel); setSparseErrors(hDataTriggerSelVtxCut); setSparseErrors(hDataTriggerSelVtxCutZ); setSparseErrors(hDataTriggerSelVtxCutZPileUpRej); // Set multiplicity range, if desired. Note that mult and pT axes are the same for all histos Int_t lowerCentralityBinLimit = -1; Int_t upperCentralityBinLimit = -2; Bool_t restrictCentralityAxis = kFALSE; Double_t actualLowerCentrality = -1.; Double_t actualUpperCentrality = -1.; if (lowerCentrality >= -1 && upperCentrality >= -1) { // Add subtract a very small number to avoid problems with values right on the border between to bins lowerCentralityBinLimit = hNumEventsTriggerSel->GetXaxis()->FindFixBin(lowerCentrality + 0.001); upperCentralityBinLimit = hNumEventsTriggerSel->GetXaxis()->FindFixBin(upperCentrality - 0.001); // Check if the values look reasonable if (lowerCentralityBinLimit <= upperCentralityBinLimit && lowerCentralityBinLimit >= 1 && upperCentralityBinLimit <= hNumEventsTriggerSel->GetXaxis()->GetNbins()) { actualLowerCentrality = hNumEventsTriggerSel->GetXaxis()->GetBinLowEdge(lowerCentralityBinLimit); actualUpperCentrality = hNumEventsTriggerSel->GetXaxis()->GetBinUpEdge(upperCentralityBinLimit); restrictCentralityAxis = kTRUE; } else { std::cout << std::endl; std::cout << "Requested centrality range out of limits or upper and lower limit are switched!" << std::endl; return -1; } } if (!restrictCentralityAxis) GetAxisRangeForMultiplicityAxisForMB(hNumEventsTriggerSel->GetXaxis(), lowerCentralityBinLimit, upperCentralityBinLimit); hNumEventsTriggerSel->GetXaxis()->SetRange(lowerCentralityBinLimit, upperCentralityBinLimit); actualLowerCentrality = hNumEventsTriggerSel->GetXaxis()->GetBinLowEdge(hNumEventsTriggerSel->GetXaxis()->GetFirst()); actualUpperCentrality = hNumEventsTriggerSel->GetXaxis()->GetBinUpEdge(hNumEventsTriggerSel->GetXaxis()->GetLast()); std::cout << "centrality: "; if (restrictCentralityAxis) { std::cout << actualLowerCentrality << " - " << actualUpperCentrality << std::endl; std::cout << "WARNING: Does it really make sense to restrict the centrality? Usually, centrality estimators imply centrality >= 0!" << std::endl; } else std::cout << "MB (" << actualLowerCentrality << " - " << actualUpperCentrality << ")" << std::endl; if (restrictCentralityAxis) { hDataTriggerSel->GetAxis(iMult)->SetRange(lowerCentralityBinLimit, upperCentralityBinLimit); hDataTriggerSelVtxCut->GetAxis(iMult)->SetRange(lowerCentralityBinLimit, upperCentralityBinLimit); hDataTriggerSelVtxCutZ->GetAxis(iMult)->SetRange(lowerCentralityBinLimit, upperCentralityBinLimit); hDataTriggerSelVtxCutZPileUpRej->GetAxis(iMult)->SetRange(lowerCentralityBinLimit, upperCentralityBinLimit); } // Restrict eta range const Int_t lowerEtaBinLimit = hDataTriggerSel->GetAxis(iEta)->FindFixBin(etaLow + 0.0001); const Int_t upperEtaBinLimit = hDataTriggerSel->GetAxis(iEta)->FindFixBin(etaUp - 0.0001); const Double_t actualLowerEta = hDataTriggerSel->GetAxis(iEta)->GetBinLowEdge(lowerEtaBinLimit); const Double_t actualUpperEta = hDataTriggerSel->GetAxis(iEta)->GetBinUpEdge(upperEtaBinLimit); std::cout << "Eta: "; std::cout << actualLowerEta << " - " << actualUpperEta << std::endl; Bool_t symmetricInEta = TMath::Abs(TMath::Abs(actualLowerEta) - TMath::Abs(actualUpperEta)) < 1e-6; TString etaRange = symmetricInEta ? Form("|#it{#eta}| < %.1f", TMath::Abs(actualLowerEta)) : Form("%.1f < #it{#eta} < %.1f", actualLowerEta, actualUpperEta); hDataTriggerSel->GetAxis(iEta)->SetRange(lowerEtaBinLimit, upperEtaBinLimit); hDataTriggerSelVtxCut->GetAxis(iEta)->SetRange(lowerEtaBinLimit, upperEtaBinLimit); hDataTriggerSelVtxCutZ->GetAxis(iEta)->SetRange(lowerEtaBinLimit, upperEtaBinLimit); hDataTriggerSelVtxCutZPileUpRej->GetAxis(iEta)->SetRange(lowerEtaBinLimit, upperEtaBinLimit); // Obtain number of events for each class // Note: Under- and overflow automatically taken into account for unrestricted axis by using -1 and -2 for limits const Double_t numEvtsTriggerSel = hNumEventsTriggerSel->Integral(lowerCentralityBinLimit, upperCentralityBinLimit); const Double_t numEvtsTriggerSelVtxCut = hNumEventsTriggerSelVtxCut->Integral(lowerCentralityBinLimit, upperCentralityBinLimit); const Double_t numEvtsTriggerSelVtxCutZ = hNumEventsTriggerSelVtxCutZ->Integral(lowerCentralityBinLimit, upperCentralityBinLimit); const Double_t numEvtsTriggerSelVtxCutZPileUpRej = hNumEventsTriggerSelVtxCutZPileUpRej->Integral(lowerCentralityBinLimit, upperCentralityBinLimit); // Project pT spectra TH1D* hSpectraTriggerSel = (TH1D*)hDataTriggerSel->Projection(iPt, "e"); TH1D* hSpectraTriggerSelVtxCut = (TH1D*)hDataTriggerSelVtxCut->Projection(iPt, "e"); TH1D* hSpectraTriggerSelVtxCutZ = (TH1D*)hDataTriggerSelVtxCutZ->Projection(iPt, "e"); TH1D* hSpectraTriggerSelVtxCutZPileUpRej = (TH1D*)hDataTriggerSelVtxCutZPileUpRej->Projection(iPt, "e"); // Normalise histos to 1/Nevt dN/dPt normaliseHist(hSpectraTriggerSel, numEvtsTriggerSel); normaliseHist(hSpectraTriggerSelVtxCut, numEvtsTriggerSelVtxCut); normaliseHist(hSpectraTriggerSelVtxCutZ, numEvtsTriggerSelVtxCutZ); normaliseHist(hSpectraTriggerSelVtxCutZPileUpRej, numEvtsTriggerSelVtxCutZPileUpRej); setupHist(hSpectraTriggerSel, kBlack, "Trigger selection"); setupHist(hSpectraTriggerSelVtxCut, kRed, "& vertex cut"); setupHist(hSpectraTriggerSelVtxCutZ, kBlue, "& vertex #it{z} cut"); setupHist(hSpectraTriggerSelVtxCutZPileUpRej, kGreen, "& pile-up rejection"); TCanvas* canvSpectra = new TCanvas("canvSpectra", "Spectra", 760, 420); canvSpectra->SetLogx(); canvSpectra->SetLogy(); canvSpectra->SetGrid(0, 0); SetCanvasMargins(canvSpectra); TLegend* leg = new TLegend(0.14, 0.26, 0.62, 0.55); leg->SetHeader(Form("MC pp #sqrt{s}=7 TeV, inclusive, %s", etaRange.Data())); leg->AddEntry(hSpectraTriggerSel, "", "l"); leg->AddEntry(hSpectraTriggerSelVtxCut, "", "l"); leg->AddEntry(hSpectraTriggerSelVtxCutZ, "", "l"); if (drawPileUp) leg->AddEntry(hSpectraTriggerSelVtxCutZPileUpRej, "", "l"); SetupLegend(leg); leg->SetMargin(0.15); hSpectraTriggerSel->Draw(); hSpectraTriggerSelVtxCut->Draw("same"); hSpectraTriggerSelVtxCutZ->Draw("same"); if (drawPileUp) hSpectraTriggerSelVtxCutZPileUpRej->Draw("same"); leg->Draw("same"); // Ratios (take binomial errors, since real sub-samples) TH1D* hRatioVtxCut = new TH1D(*hSpectraTriggerSelVtxCut); hRatioVtxCut->SetName("hRatioVtxCut"); setupHist(hRatioVtxCut, kBlack, "MB & vtx / MB"); hRatioVtxCut->GetYaxis()->SetTitle("1/#it{N}_{evt} d#it{N}/d#it{p}_{T}^{gen} ratio"); hRatioVtxCut->Divide(hRatioVtxCut, hSpectraTriggerSel, 1., 1., "B"); hRatioVtxCut->GetYaxis()->SetRangeUser(1.08, 1.14); // Mean ratio of spectra and of Nevt TF1* funcRatioVtxCut = new TF1("funcRatioVtxCut", "pol0", 0.15, hRatioVtxCut->GetXaxis()->GetBinUpEdge(hSpectraTriggerSelVtxCut->FindLastBinAbove(0))); funcRatioVtxCut->SetLineWidth(2); funcRatioVtxCut->SetLineColor(kRed); hRatioVtxCut->Fit(funcRatioVtxCut, "N"); const Double_t meanRatioVtxCut = funcRatioVtxCut->GetParameter(0); const Double_t ratioNevtVtxCut = numEvtsTriggerSelVtxCut > 0 ? numEvtsTriggerSel / numEvtsTriggerSelVtxCut : -1.; const Double_t doubleRatioMinusOne = meanRatioVtxCut > 0 ? (ratioNevtVtxCut / meanRatioVtxCut - 1.) : -999.; TH1D* hRatioVtxCutZ = new TH1D(*hSpectraTriggerSelVtxCutZ); hRatioVtxCutZ->SetName("hRatioVtxCutZ"); setupHist(hRatioVtxCutZ, kBlack, "MB & vtx & #it{z} vtx / MB & vtx"); hRatioVtxCutZ->GetYaxis()->SetTitle("1/#it{N}_{evt} d#it{N}/d#it{p}_{T}^{gen} ratio"); hRatioVtxCutZ->Divide(hRatioVtxCutZ, hSpectraTriggerSelVtxCut, 1., 1., "B"); hRatioVtxCutZ->GetYaxis()->SetRangeUser(0.95, 1.05); // Mean ratio of spectra and of Nevt TF1* funcRatioVtxCutZ = new TF1("funcRatioVtxCutZ", "pol0", 0.15, hRatioVtxCutZ->GetXaxis()->GetBinUpEdge(hSpectraTriggerSelVtxCutZ->FindLastBinAbove(0))); hRatioVtxCutZ->Fit(funcRatioVtxCutZ, "N"); funcRatioVtxCutZ->SetLineWidth(2); funcRatioVtxCutZ->SetLineColor(kRed); const Double_t meanRatioVtxCutZ = funcRatioVtxCutZ->GetParameter(0); const Double_t ratioNevtVtxCutZ = numEvtsTriggerSelVtxCutZ > 0 ? numEvtsTriggerSelVtxCut / numEvtsTriggerSelVtxCutZ : -1.; TH1D* hRatioPileUp = new TH1D(*hSpectraTriggerSelVtxCutZPileUpRej); hRatioPileUp->SetName("hRatioPileUp"); setupHist(hRatioPileUp, kBlack, "MB & vtx & #it{z} vtx & pile-up / MB & vtx & #it{z} vtx"); hRatioPileUp->GetYaxis()->SetTitle("1/#it{N}_{evt} d#it{N}/d#it{p}_{T}^{gen} ratio"); hRatioPileUp->Divide(hRatioPileUp, hSpectraTriggerSelVtxCutZ, 1., 1., "B"); /* TF1* funcRatioPileUp = new TF1("funcRatioPileUp", "pol0", 0.15, hRatioPileUp->GetXaxis()->GetBinUpEdge(hSpectraTriggerSelVtxCutZPileUpRej->FindLastBinAbove(0))); hRatioPileUp->Fit(funcRatioPileUp, "N");*/ ClearTitleFromHistoInCanvas(canvSpectra); TCanvas* canvRatioVtx = new TCanvas("canvRatioVtx", "Ratio vertex", 760, 420); canvRatioVtx->SetLogx(); canvRatioVtx->SetGrid(0, 1); SetCanvasMargins(canvRatioVtx); hRatioVtxCut->Draw(); funcRatioVtxCut->Draw("same"); TLegend* leg2 = new TLegend(0.22, 0.7, drawPileUp ? 0.87 : 0.72, 0.9); leg2->SetHeader(Form("MC pp #sqrt{s}=7 TeV, inclusive, %s", etaRange.Data())); leg2->AddEntry(hRatioVtxCut, "", "l"); SetupLegend(leg2); leg2->SetMargin(0.1); leg2->Draw("same"); ClearTitleFromHistoInCanvas(canvRatioVtx); TCanvas* canvRatioOther = new TCanvas("canvRatioOther", "Ratio others", 760, 420); canvRatioOther->SetLogx(); canvRatioOther->SetGrid(0, 1); SetCanvasMargins(canvRatioOther); hRatioVtxCutZ->Draw(); if (drawPileUp) hRatioPileUp->Draw("same"); TLegend* leg3 = new TLegend(0.22, drawPileUp ? 0.63 : 0.7, drawPileUp ? 0.87 : 0.72, 0.9); leg3->SetHeader(Form("MC pp #sqrt{s}=7 TeV, inclusive, %s", etaRange.Data())); leg3->AddEntry(hRatioVtxCutZ, "", "l"); if (drawPileUp) leg3->AddEntry(hRatioPileUp, "", "l"); SetupLegend(leg3); leg3->SetMargin(0.1); leg3->Draw("same"); ClearTitleFromHistoInCanvas(canvRatioOther); printf("meanRatioVtxCut %f <-> ratioNevtVtxCut %f => meanRatioVtxCutZ/ratioNevtVtxCutZ - 1 = %f\nmeanRatioVtxCutZ %f <-> ratioNevtVtxCutZ %f\n", meanRatioVtxCut, ratioNevtVtxCut, doubleRatioMinusOne, meanRatioVtxCutZ, ratioNevtVtxCutZ); TNamed* settings = new TNamed( Form("Settings: Data file \"%s\", lowerEta %.2f, uppEta %.2f, lowerCentrality %.3f, upperCentrality %.3f, doubleRatioMinusOne %.4f\n", pathNameData.Data(), etaLow, etaUp, lowerCentrality, upperCentrality, doubleRatioMinusOne), ""); // Save results to file TString saveFileName = pathNameData; saveFileName = Form("%s_binZeroStudy.root", saveFileName.ReplaceAll(".root", "").Data()); TFile *saveFile = TFile::Open(saveFileName.Data(), "RECREATE"); saveFile->cd(); hSpectraTriggerSel->Write(); hSpectraTriggerSelVtxCut->Write(); hSpectraTriggerSelVtxCutZ->Write(); hSpectraTriggerSelVtxCutZPileUpRej->Write(); hRatioVtxCut->Write(); hRatioVtxCutZ->Write(); hRatioPileUp->Write(); funcRatioVtxCut->Write(); funcRatioVtxCutZ->Write(); canvSpectra->Write(); canvRatioVtx->Write(); canvRatioOther->Write(); settings->Write(); saveFile->Close(); TString temp = saveFileName; canvRatioVtx->SaveAs(Form("%s", temp.ReplaceAll(".root", "_ratioVtx.pdf").Data())); temp = saveFileName; canvRatioOther->SaveAs(Form("%s", temp.ReplaceAll(".root", "_ratioOther.pdf").Data())); PrintSettingsAxisRangeForMultiplicityAxisForMB(); return 0; }
///////////////// // MAIN SCRIPT // ///////////////// void paperConvert() { gStyle->SetHistLineWidth(2); gStyle->SetOptStat(""); TH1::SetDefaultSumw2(); TCanvas *c1 = new TCanvas("c1", "c1",10,32,700,500); gStyle->SetOptStat(0); // For centralised hist with no title, legend inside plot c1->Range(-1.705566,0.8486743,10.78995,1.08077); c1->SetFillColor(0); c1->SetBorderMode(0); c1->SetBorderSize(2); c1->SetTickx(1); c1->SetTicky(1); c1->SetLeftMargin(0.1364942); c1->SetRightMargin(0.06321839); c1->SetTopMargin(0.07415254); c1->SetBottomMargin(0.1271186); c1->SetFrameBorderMode(0); c1->SetFrameBorderMode(0); TFile *f_sig_main1 = TFile::Open("Signal_1prong_HLT_bare/output_main_bare_sig_muRand_HLT_dR1.root", "READ"); TFile *f_sig_main2 = TFile::Open("Signal_1prong_HLT_bare/output_main_bare_sig_muRand_HLT_dR2.root", "READ"); TFile *f_sig_mass1 = TFile::Open("Signal_1prong_HLT_bare/output_bare_sig_muRand_HLT_dR1.root", "READ"); TFile *f_sig_mass2 = TFile::Open("Signal_1prong_HLT_bare/output_bare_sig_muRand_HLT_dR2.root", "READ"); TFile *f_bg_main1 = TFile::Open("QCDb_HLT_bare/output_main_bare_bg_muRand_HLT_dR1.root", "READ"); // TFile *f_bg_main2 = TFile::Open("QCDb_HLT_bare/output_main_bare_bg_muRand_HLT_dR2.root", "READ"); TFile *f_bg_main2 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_noDz_dR2.root", "READ"); // TFile *f_bg_mass1 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_dR1.root", "READ"); // TFile *f_bg_mass1 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_1912_dR1.root", "READ"); TFile *f_bg_mass1 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_1912IPopt2_dR1.root", "READ"); // TFile *f_bg_mass2 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_dR2.root", "READ"); //normal // TFile *f_bg_mass2 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_looseIsoAndTau_dR2.root", "READ"); // TFile *f_bg_mass2 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_IPiso0p5_dR2.root", "READ"); // TFile *f_bg_mass2 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_1912_dR2.root", "READ"); TFile *f_bg_mass2 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_1912IPopt2_dR2.root", "READ"); // TFile *f_bg_mass2 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_noDz_dR2.root", "READ"); // TFile *f_bg_mass2 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_IPopt2_dR2.root", "READ"); // TFile *f_bg_mass2 = TFile::Open("QCDb_HLT_bare/output_bare_bg_muRand_HLT_IPopt3_dR2.root", "READ"); TFile *f_scatter_main1 = TFile::Open("QCDbcScatter_HLT_bare/output_main_bare_bg_muRand_HLT_dR1.root", "READ"); TFile *f_scatter_main2 = TFile::Open("QCDbcScatter_HLT_bare/output_main_bare_bg_muRand_HLT_dR2.root", "READ"); TFile *f_scatter_mass1 = TFile::Open("QCDbcScatter_HLT_bare/output_bare_bg_muRand_HLT_dR1.root", "READ"); TFile *f_scatter_mass2 = TFile::Open("QCDbcScatter_HLT_bare/output_bare_bg_muRand_HLT_dR2.root", "READ"); // TString dir("normal"); // TString dir("looseIsolooseTau"); // TString dir("IPiso0p5"); // TString dir("1912"); TString dir("1912IPopt2"); // TString dir("IPopt2"); // TString dir("noDz"); /////////////////// // 1D MASS PLOTS // /////////////////// //////////////// // Signal region plots //////////////// std::vector<TFile*> filesdR2; filesdR2.push_back(f_bg_mass2); filesdR2.push_back(f_scatter_mass2); TPaveText* t_signal = new TPaveText(0.6, 0.47, 0.85, 0.58, "NDC"); t_signal->AddText("Signal region"); t_signal->SetFillColor(kWhite); t_signal->SetBorderSize(0); TPaveText* t_side = new TPaveText(0.6, 0.47, 0.84, 0.57, "NDC"); t_side->AddText("Control region B"); t_side->SetFillColor(kWhite); t_side->SetBorderSize(0); // bbbar only TH1D* hM1_bare_bg_muRand_HLT_dR2 = (TH1D*) f_bg_mass2->Get("hM1"); TH1D* hM2_bare_bg_muRand_HLT_dR2 = (TH1D*) f_bg_mass2->Get("hM2"); TH1D* hM_bare_bg_muRand_HLT_dR2 = (TH1D*)hM1_bare_bg_muRand_HLT_dR2->Clone(); hM_bare_bg_muRand_HLT_dR2->Add(hM2_bare_bg_muRand_HLT_dR2); normaliseHist(hM_bare_bg_muRand_HLT_dR2); // as we added m1 + m2 setMassAUTitles(hM_bare_bg_muRand_HLT_dR2); doBGHist(hM_bare_bg_muRand_HLT_dR2); setAltTitleLabelSizes(hM_bare_bg_muRand_HLT_dR2); hM_bare_bg_muRand_HLT_dR2->Draw("HISTE"); t_signal->Draw(); c1->SaveAs("Combined/"+dir+"/M_10bins_bare_bg_muRand_HLT_dR2.pdf"); std::vector<double> scalingFactors; scalingFactors.push_back(1.7649); scalingFactors.push_back(2.6577); // // bbbar + scatter TH1D* hM1_bg_dR2 = combineRebin10bins(filesdR2, "hM1_unnormalised", scalingFactors); TH1D* hM2_bg_dR2 = combineRebin10bins(filesdR2, "hM2_unnormalised", scalingFactors); TH1D* hM_bg_dR2 = (TH1D*) hM1_bg_dR2->Clone() ; hM_bg_dR2->Add(hM2_bg_dR2); normaliseHist(hM_bg_dR2); setMassAUTitles(hM_bg_dR2); doBGHist(hM_bg_dR2); setAltTitleLabelSizes(hM_bg_dR2); hM_bg_dR2->Draw("HISTE"); t_signal->Draw(); c1->SaveAs("Combined/"+dir+"/M_10bins_bare_bg_both_muRand_HLT_dR2.pdf"); // signal TH1D* hM1_bare_sig_muRand_HLT_dR2 = (TH1D*) f_sig_mass2->Get("hM1"); TH1D* hM2_bare_sig_muRand_HLT_dR2 = (TH1D*) f_sig_mass2->Get("hM2"); TH1D* hM_bare_sig_muRand_HLT_dR2 = (TH1D*)hM1_bare_sig_muRand_HLT_dR2->Clone(); hM_bare_sig_muRand_HLT_dR2->Add(hM2_bare_sig_muRand_HLT_dR2); normaliseHist(hM_bare_sig_muRand_HLT_dR2); setMassAUTitles(hM_bare_sig_muRand_HLT_dR2); doSignalHist(hM_bare_sig_muRand_HLT_dR2); setAltTitleLabelSizes(hM_bare_sig_muRand_HLT_dR2); hM_bare_sig_muRand_HLT_dR2->Draw("HISTE"); t_signal->Draw(); c1->SaveAs("Combined/"+dir+"/M_10bins_bare_sig_muRand_HLT_dR2.pdf"); // bbbar + signal THStack* st = new THStack("st",""); st->Add(hM_bare_bg_muRand_HLT_dR2); st->Add(hM_bare_sig_muRand_HLT_dR2); TLegend* l = new TLegend(0.67, 0.67, 0.88, 0.88); l->AddEntry(hM_bare_bg_muRand_HLT_dR2, "QCD b#bar{b} MC", "lp"); l->AddEntry(hM_bare_sig_muRand_HLT_dR2, "#splitline{Signal MC}{m_{#phi} = 8 GeV}", "lp"); doStandardLegend(l); st->Draw("NOSTACK HISTE"); setMassAUTitles(st->GetHistogram()); setAltTitleLabelSizes(st->GetHistogram()); l->Draw(); t_signal->Draw(); c1->SaveAs("Combined/"+dir+"/M_10bins_bare_both_muRand_HLT_dR2.pdf"); // bbbar + scatter + signal THStack* st_all = new THStack("st_all",""); st_all->Add(hM_bg_dR2); st_all->Add(hM_bare_sig_muRand_HLT_dR2); TLegend* l_all = new TLegend(0.52,0.62,0.86,0.89); l_all->AddEntry(hM_bg_dR2,"Gen. level QCD MC","lp"); l_all->AddEntry((TObject*)0,"(b#bar{b} + q-g scatter,",""); //null pointers for blank entries l_all->AddEntry((TObject*)0,"q = b, #bar{b}, c, #bar{c})",""); l_all->AddEntry(hM_bare_sig_muRand_HLT_dR2, "Signal MC", "lp"); l_all->AddEntry((TObject*)0,"m_{#phi} = 8 GeV", ""); doStandardLegend(l_all); st_all->Draw("NOSTACKHISTE"); setMassAUTitles(st_all->GetHistogram()); setAltTitleLabelSizes(st_all->GetHistogram()); l_all->Draw(); t_signal->Draw(); c1->SaveAs("Combined/"+dir+"/M_10bins_bare_allMC_muRand_HLT_dR2.pdf"); //////////// // sideband plots //////////// std::vector<TFile*> filesdR1; filesdR1.push_back(f_bg_mass1); filesdR1.push_back(f_scatter_mass1); // bbbar TH1D* hM1_side_bg_muRand_HLT_dR1 = (TH1D*) f_bg_mass1->Get("hM1_side_1to2p5"); hM1_side_bg_muRand_HLT_dR1->Rebin(5); TH1D* hM2_side_bg_muRand_HLT_dR1 = (TH1D*) f_bg_mass1->Get("hM2_side_1to2p5"); hM2_side_bg_muRand_HLT_dR1->Rebin(5); TH1D* hM_side_bg_muRand_HLT_dR1 = (TH1D*)hM1_side_bg_muRand_HLT_dR1->Clone(); hM_side_bg_muRand_HLT_dR1->Add(hM2_side_bg_muRand_HLT_dR1); normaliseHist(hM_side_bg_muRand_HLT_dR1); setMassAUTitles(hM_side_bg_muRand_HLT_dR1); doBGHist(hM_side_bg_muRand_HLT_dR1); setAltTitleLabelSizes(hM_side_bg_muRand_HLT_dR1); hM_side_bg_muRand_HLT_dR1->Draw("HISTE"); t_side->Draw(); c1->SaveAs("Combined/"+dir+"/M_10bins_side_bg_muRand_HLT_dR1.pdf"); // // bbbar + scatter TH1D* hM1_side_bg_dR1 = combineRebin10bins(filesdR1, "hM1_side_1to2p5_unnormalised", scalingFactors); TH1D* hM2_side_bg_dR1 = combineRebin10bins(filesdR1, "hM1_side_1to2p5_unnormalised", scalingFactors); TH1D* hM_side_bg_dR1 = (TH1D*) hM1_side_bg_dR1->Clone(); hM_side_bg_dR1->Add(hM2_side_bg_dR1); normaliseHist(hM_side_bg_dR1); setMassAUTitles(hM_side_bg_dR1); doBGHist(hM_side_bg_dR1); setAltTitleLabelSizes(hM_side_bg_dR1); hM_side_bg_dR1->Draw("HISTE"); t_side->Draw(); c1->SaveAs("Combined/"+dir+"/M_10bins_side_bg_both_muRand_HLT_dR1.pdf"); // signal TH1D* hM1_side_sig_muRand_HLT_dR1 = (TH1D*) f_sig_mass1->Get("hM1_side_1to2p5"); hM1_side_sig_muRand_HLT_dR1->Rebin(5); TH1D* hM2_side_sig_muRand_HLT_dR1 = (TH1D*) f_sig_mass1->Get("hM2_side_1to2p5"); hM2_side_sig_muRand_HLT_dR1->Rebin(5); TH1D* hM_side_sig_muRand_HLT_dR1 = (TH1D*)hM1_side_sig_muRand_HLT_dR1->Clone(); hM_side_sig_muRand_HLT_dR1->Add(hM2_side_sig_muRand_HLT_dR1); normaliseHist(hM_side_sig_muRand_HLT_dR1); setMassAUTitles(hM_side_sig_muRand_HLT_dR1); doSignalHist(hM_side_sig_muRand_HLT_dR1); setAltTitleLabelSizes(hM_side_sig_muRand_HLT_dR1); hM_side_sig_muRand_HLT_dR1->Draw("HISTE"); t_side->Draw(); c1->SaveAs("Combined/"+dir+"/M_10bins_side_sig_muRand_HLT_dR1.pdf"); // bbar + signal THStack* st_side = new THStack("st_side",""); st_side->Add(hM_side_bg_muRand_HLT_dR1); st_side->Add(hM_side_sig_muRand_HLT_dR1); st_side->Draw("NOSTACK HISTE"); setMassAUTitles(st_side->GetHistogram()); setAltTitleLabelSizes(st_side->GetHistogram()); l->Draw(); t_side->Draw(); c1->SaveAs("Combined/"+dir+"/M_10bins_side_both_muRand_HLT_dR1.pdf"); // bbar + scatter + signal THStack* st_side_all = new THStack("st_side_all",""); st_side_all->Add(hM_side_bg_dR1); st_side_all->Add(hM_side_sig_muRand_HLT_dR1); st_side_all->Draw("NOSTACK HISTE"); setMassAUTitles(st_side_all->GetHistogram()); setAltTitleLabelSizes(st_side_all->GetHistogram()); l_all->Draw(); t_side->Draw(); c1->SaveAs("Combined/"+dir+"/M_10bins_side_allMC_muRand_HLT_dR1.pdf"); /////////////////////// // CORRELATION PLOTS // /////////////////////// //signal mc TH1D* hCorr_bare_sig = (TH1D*) f_sig_mass2->Get("hCorr1D"); TH1D* hCorr_side_sig = (TH1D*) f_sig_mass1->Get("hCorr1D_side_1to2p5"); //bbbar TH1D* hCorr_bare_b = (TH1D*) f_bg_mass2->Get("hCorr1D"); // TH1D* hCorr_bare_b = (TH1D*) f_bg_mass2->Get("hCorr1D_loosetau"); TH1D* hCorr_side_b = (TH1D*) f_bg_mass1->Get("hCorr1D_side_1to2p5"); TH1D* hM1D_bare_b_unnormalised = (TH1D*) f_bg_mass2->Get("hM_unnormalised"); // signal region TH2D* hM2D_bare_b_unnormalised = (TH2D*) f_bg_mass2->Get("hM1vsM2_unnormalised"); TH1D* hM1D_side_b_unnormalised = (TH1D*) f_bg_mass1->Get("hM_side_1to2p5_unnormalised"); //sideband TH2D* hM2D_side_b_unnormalised = (TH2D*) f_bg_mass1->Get("hM1vsM2_side_1to2p5_unnormalised"); // scatter TH1D* hCorr_bare_scatter = (TH1D*) f_scatter_mass2->Get("hCorr1D"); TH1D* hCorr_side_scatter = (TH1D*) f_scatter_mass1->Get("hCorr1D_side_1to2p5"); TH1D* hM1D_bare_scatter_unnormalised = (TH1D*) f_scatter_mass2->Get("hM_unnormalised"); //signal region TH2D* hM2D_bare_scatter_unnormalised = (TH2D*) f_scatter_mass2->Get("hM1vsM2_unnormalised"); TH1D* hM1D_side_scatter_unnormalised = (TH1D*) f_scatter_mass1->Get("hM_side_1to2p5_unnormalised"); //sideband TH2D* hM2D_side_scatter_unnormalised = (TH2D*) f_scatter_mass1->Get("hM1vsM2_side_1to2p5_unnormalised"); t_signal = new TPaveText(0.15, 0.7, 0.4, 0.8, "NDC"); t_signal->AddText("Signal region"); t_signal->SetFillColor(kWhite); t_signal->SetBorderSize(0); t_side = new TPaveText(0.15, 0.7, 0.4, 0.8, "NDC"); t_side->AddText("Control region B"); t_side->SetFillColor(kWhite); t_side->SetBorderSize(0); // set title sizes, titles, max, min, etc setTitleLabelSizes(hCorr_bare_sig); doSignalHist(hCorr_bare_sig); setCorrTitlesMaxMin(hCorr_bare_sig); setTitleLabelSizes(hCorr_side_sig); doSignalHist(hCorr_side_sig); setCorrTitlesMaxMin(hCorr_side_sig); setTitleLabelSizes(hCorr_bare_b); doBGHist(hCorr_bare_b); setCorrTitlesMaxMin(hCorr_bare_b); setTitleLabelSizes(hCorr_side_b); doBGHist(hCorr_side_b); setCorrTitlesMaxMin(hCorr_side_b); setTitleLabelSizes(hCorr_bare_scatter); doAltBGHist(hCorr_bare_scatter); setCorrTitlesMaxMin(hCorr_bare_scatter); setTitleLabelSizes(hCorr_side_scatter); doAltBGHist(hCorr_side_scatter); setCorrTitlesMaxMin(hCorr_side_scatter); TLine line(0,1,10,1); line.SetLineStyle(2); line.SetLineColor(12); line.SetLineWidth(2); c1->SetTicks(1,1); TLegend* l_bonly = new TLegend(0.6, 0.82, 0.88, 0.88); l_bonly->AddEntry(hCorr_bare_b, "QCD b#bar{b} MC", "lp"); doStandardLegend(l_bonly); /////////////////// // signal region // /////////////////// // signal MC by itself hCorr_bare_sig->Draw(); line.Draw(); t_signal->Draw(); c1->SaveAs("Combined/"+dir+"/Corr_bare_sig.pdf"); // bbbar qcd by itself std::cout << "bbbar QCD MC in signal region:" << std::endl; printBinContents(hCorr_bare_b); hCorr_bare_b->Draw(); line.Draw(); t_signal->Draw(); l_bonly->Draw(); c1->SaveAs("Combined/"+dir+"/Corr_bare_b.pdf"); c1->SaveAs("Combined/"+dir+"/Corr_bare_b.png"); // bbbar + signal hCorr_bare_b->Draw(); hCorr_bare_sig->Draw("SAME"); line.Draw(); l->Draw(); c1->SaveAs("Combined/"+dir+"/Corr_bare_b_sig.pdf"); // make combined corr plot for both qcd std::vector<TH1D*> bare_bg_hists1D; bare_bg_hists1D.push_back(hM1D_bare_b_unnormalised); bare_bg_hists1D.push_back(hM1D_bare_scatter_unnormalised); TH1D* hM1D_bare_bg = combineScale(bare_bg_hists1D, scalingFactors); std::vector<TH2D*> bare_bg_hists2D; bare_bg_hists2D.push_back(hM2D_bare_b_unnormalised); bare_bg_hists2D.push_back(hM2D_bare_scatter_unnormalised); TH2D* hM2D_bare_bg = combineScale(bare_bg_hists2D, scalingFactors); TH1D* hCorr_bare_bg = createCorrelationPlot(hM2D_bare_bg, hM1D_bare_bg); // both QCD summed together doBGHist(hCorr_bare_bg); setTitleLabelSizes(hCorr_bare_bg); setCorrTitlesMaxMin(hCorr_bare_bg); hCorr_bare_bg->Draw(); line.Draw(); t_signal->Draw(); c1->SaveAs("Combined/"+dir+"/Corr_bare_bg.pdf"); // all qcd + signal mc hCorr_bare_sig->Draw("SAME"); l_all->Draw(); c1->SaveAs("Combined/"+dir+"/Corr_bare_bg_sig.pdf"); ////////////////////// // control region B // ////////////////////// // signal MC by itself hCorr_side_sig->Draw(); line.Draw(); c1->SaveAs("Combined/"+dir+"/Corr_side_sig.pdf"); // bbbar qcd by itself std::cout << "bbbar QCD MC in control region:" << std::endl; printBinContents(hCorr_side_b); hCorr_side_b->Draw(); line.Draw(); l_bonly->Draw(); c1->SaveAs("Combined/"+dir+"/Corr_side_b.pdf"); c1->SaveAs("Combined/"+dir+"/Corr_side_b.png"); // signal + bbbar together hCorr_side_sig->Draw(); hCorr_side_b->Draw("SAME"); line.Draw(); l->Draw(); c1->SaveAs("Combined/"+dir+"/Corr_side_b_sig.pdf"); // make combined corr plot for both qcd std::vector<TH1D*> side_bg_hists1D; side_bg_hists1D.push_back(hM1D_side_b_unnormalised); side_bg_hists1D.push_back(hM1D_side_scatter_unnormalised); TH1D* hM1D_side_bg = combineScale(side_bg_hists1D, scalingFactors); std::vector<TH2D*> side_bg_hists2D; side_bg_hists2D.push_back(hM2D_side_b_unnormalised); side_bg_hists2D.push_back(hM2D_side_scatter_unnormalised); TH2D* hM2D_side_bg = combineScale(side_bg_hists2D, scalingFactors); TH1D* hCorr_side_bg = createCorrelationPlot(hM2D_side_bg, hM1D_side_bg); // both QCD summed together doBGHist(hCorr_side_bg); setTitleLabelSizes(hCorr_side_bg); setCorrTitlesMaxMin(hCorr_side_bg); hCorr_side_bg->Draw(); line.Draw(); t_side->Draw(); c1->SaveAs("Combined/"+dir+"/Corr_side_bg.pdf"); // signal + both QCD hCorr_side_sig->Draw("SAME"); l_all->Draw(); c1->SaveAs("Combined/"+dir+"/Corr_side_all_MC.pdf"); // QCD + data hCorr_side_bg->Draw(); TH1D* hCorr_side_data = dataCorr_side(); doDataHist(hCorr_side_data); setCorrTitlesMaxMin(hCorr_side_data); hCorr_side_data->Draw("SAME"); line.Draw(); TLegend* l_all_data = new TLegend(0.52,0.65,0.86,0.89); l_all_data->AddEntry(hM_bg_dR2,"Gen. level QCD MC","lp"); l_all_data->AddEntry((TObject*)0,"(b#bar{b} + q-g scatter,",""); //null pointers for blank entries l_all_data->AddEntry((TObject*)0,"q = b, #bar{b}, c, #bar{c})",""); l_all_data->AddEntry(hCorr_side_data, "Data", "lp"); doStandardLegend(l_all_data); l_all_data->Draw(); t_side->Draw(); c1->SaveAs("Combined/"+dir+"/Corr_side_bg_data.pdf"); // c1->SaveAs("Combined/"+dir+"/Corr_side_bg_data.png"); // bbar + data hCorr_side_b->Draw(); hCorr_side_data->Draw("SAME"); TLegend* l_b_data = new TLegend(0.6,0.7,0.86,0.89); l_b_data->AddEntry(hM_bg_dR2,"QCD b#bar{b} MC","lp"); l_b_data->AddEntry(hCorr_side_data, "Data", "lp"); doStandardLegend(l_b_data); l_b_data->Draw(); line.Draw(); t_side->Draw(); c1->SaveAs("Combined/"+dir+"/Corr_side_b_data.pdf"); c1->SaveAs("Combined/"+dir+"/Corr_side_b_data.png"); ///////////////////////// // TRACK DISTRIBUTIONS // ///////////////////////// // combineHists(f_sig_main2, f_bg_main2, f_scatter_main2, "hNTracks1", "HISTE", "Combined/combined_NTrack1_muRand.pdf", scalingFactors, "Tracks with p_{T} > 2.5 GeV"); // combineHists(f_sig_main2, f_bg_main2, f_scatter_main2, "hNTracksAbs1", "HISTE", "Combined/combined_NTrackAbs1_muRand.pdf", scalingFactors, "Tracks with p_{T} > 2.5 GeV", "Average number of tracks per #mu_{1} / bin"); // combineHists(f_sig_main2, f_bg_main2, f_scatter_main2, "hNTracksAll1", "HISTE", "Combined/combined_NTrackAll1_muRand.pdf", scalingFactors, "Tracks with p_{T} > 1 GeV"); // combineHists(f_sig_main2, f_bg_main2, f_scatter_main2, "hNTracksAllAbs1", "HISTE", "Combined/combined_NTrackAllAbs1_muRand.pdf", scalingFactors, "Tracks with p_{T} > 1 GeV", "Average number of tracks per #mu_{1} / bin"); // combineHists(f_sig_main2, f_bg_main2, f_scatter_main2, "hNSoftTracks1", "HISTE", "Combined/combined_NSoftTrack1_muRand.pdf", scalingFactors, "Tracks with 1 < p_{T} < 2.5 GeV"); // combineHists(f_sig_main2, f_bg_main2, f_scatter_main2, "hNSoftTracksAbs1", "HISTE", "Combined/combined_NSoftTrackAbs1_muRand.pdf", scalingFactors, "Tracks with 1 < p_{T} < 2.5 GeV", "Average number of tracks per #mu_{1} / bin"); //////////////////////////////////////////// // mass shape as fn of # tracks about mu2 // //////////////////////////////////////////// THStack* st_Ntk2_234 = new THStack("",""); TH1D* histM1_Ntk2_2 = (TH1D*) f_bg_mass2->Get("hM1_Ntk2_2"); TH1D* histM1_Ntk2_3 = (TH1D*) f_bg_mass2->Get("hM1_Ntk2_3"); TH1D* histM1_Ntk2_4 = (TH1D*) f_bg_mass2->Get("hM1_Ntk2_4"); doStandardHist(hM1_bare_bg_muRand_HLT_dR2); // hM1_bare_bg_muRand_HLT_dR2->SetMarkerStyle(); doCustomHist(histM1_Ntk2_2, kRed, 21); doCustomHist(histM1_Ntk2_3, kBlack, 22); doCustomHist(histM1_Ntk2_4, kGreen+3, 23); st_Ntk2_234->Add(hM1_bare_bg_muRand_HLT_dR2); st_Ntk2_234->Add(histM1_Ntk2_2); st_Ntk2_234->Add(histM1_Ntk2_3); st_Ntk2_234->Add(histM1_Ntk2_4); st_Ntk2_234->Draw("NOSTACK E"); setMassAUTitles(st_Ntk2_234->GetHistogram()); st_Ntk2_234->GetHistogram()->SetXTitle("m_{1}(#mu-tk) [GeV]"); setAltTitleLabelSizes(st_Ntk2_234->GetHistogram()); TLegend* l_Ntk2_234 = new TLegend(0.56, 0.6, 0.88, 0.88); l_Ntk2_234->AddEntry((TObject*)0, "Gen. level QCD b#bar{b} MC", ""); l_Ntk2_234->AddEntry(hM1_bare_bg_muRand_HLT_dR2, "N_{tk,2} = 1", "lp"); l_Ntk2_234->AddEntry(histM1_Ntk2_2, "N_{tk,2} = 2", "lp"); l_Ntk2_234->AddEntry(histM1_Ntk2_3, "N_{tk,2} = 3", "lp"); l_Ntk2_234->AddEntry(histM1_Ntk2_4, "N_{tk,2} = 4", "lp"); doStandardLegend(l_Ntk2_234); l_Ntk2_234->Draw(); c1->SaveAs("Combined/"+dir+"/M1_Ntk2.pdf"); THStack* st_Ntk2_2or3 = new THStack("",""); TH1D* histM1_Ntk2_2or3 = (TH1D*) f_bg_mass2->Get("hM1_Ntk2_2or3"); doCustomHist(histM1_Ntk2_2or3, kRed, 22); // st_Ntk2_2or3->Add(hM1_bare_bg_muRand_HLT_dR2); st_Ntk2_2or3->Add(hM_bare_bg_muRand_HLT_dR2); st_Ntk2_2or3->Add(histM1_Ntk2_2or3); st_Ntk2_2or3->Draw("NOSTACK E"); setMassAUTitles(st_Ntk2_2or3->GetHistogram()); st_Ntk2_2or3->GetHistogram()->SetXTitle("m_{ i }(#mu-trk) [GeV]"); setAltTitleLabelSizes(st_Ntk2_2or3->GetHistogram()); TLegend* l_Ntk2_2or3 = new TLegend(0.55, 0.56, 0.88, 0.88); l_Ntk2_2or3->AddEntry((TObject*)0, "Gen. level QCD b#bar{b} MC", ""); // l_Ntk2_2or3->AddEntry(hM1_bare_bg_muRand_HLT_dR2, "N_{trk,2} = 1", "lp"); l_Ntk2_2or3->AddEntry(hM_bare_bg_muRand_HLT_dR2, "N_{trk, j} = 1", "lp"); l_Ntk2_2or3->AddEntry(histM1_Ntk2_2or3, "N_{trk, j} = 2, 3", "lp"); doStandardLegend(l_Ntk2_2or3); l_Ntk2_2or3->Draw(); c1->SaveAs("Combined/"+dir+"/M_Ntk2_2or3.pdf"); c1->SaveAs("Combined/"+dir+"/M_Ntk2_2or3.png"); histM1_Ntk2_2or3->SetMinimum(0.001); // Stop SetLogy complainng // hM1_bare_bg_muRand_HLT_dR2->SetMinimum(0.001); // Stop SetLogy complainng hM_bare_bg_muRand_HLT_dR2->SetMinimum(0.001); // Stop SetLogy complainng setAltTitleLabelSizes(st_Ntk2_2or3->GetHistogram()); c1->SetLogy(); c1->SaveAs("Combined/"+dir+"/M_Ntk2_2or3_log.pdf"); c1->SaveAs("Combined/"+dir+"/M_Ntk2_2or3_log.png"); // cleanup f_sig_main1->Close(); f_sig_main2->Close(); f_sig_mass2->Close(); f_sig_mass2->Close(); f_bg_main1->Close(); f_bg_main2->Close(); f_bg_mass1->Close(); f_bg_mass2->Close(); f_scatter_main1->Close(); f_scatter_main2->Close(); f_scatter_mass1->Close(); f_scatter_mass2->Close(); }
//___________________________________________________________________ Int_t extractPtResolution(TString pathNameData, TString listName, Int_t chargeMode /*kNegCharge = -1, kAllCharged = 0, kPosCharge = 1*/, Double_t lowerCentrality /*= -2*/, Double_t upperCentrality /*= -2*/, Double_t lowerJetPt /*= -1*/ , Double_t upperJetPt/* = -1*/) { if (listName == "") { listName = pathNameData; listName.Replace(0, listName.Last('/') + 1, ""); listName.ReplaceAll(".root", ""); } TString pathData = pathNameData; pathData.Replace(pathData.Last('/'), pathData.Length(), ""); TH1D* hPtResolutionFit[AliPID::kSPECIES] = {0x0, }; TH2D* hPtResolution[AliPID::kSPECIES] = {0x0, }; THnSparse* hPtResolutionRaw[AliPID::kSPECIES] = {0x0, }; TFile* fileData = TFile::Open(pathNameData.Data()); if (!fileData) { printf("Failed to open data file \"%s\"\n", pathNameData.Data()); return -1; } TObjArray* histList = (TObjArray*)(fileData->Get(listName.Data())); if (!histList) { printf("Failed to load list!\n"); return -1; } Double_t actualLowerCentrality = -2; Double_t actualUpperCentrality = -2; Double_t actualLowerJetPt = -1.; Double_t actualUpperJetPt = -1.; Bool_t restrictJetPtAxis = (lowerJetPt >= 0 && upperJetPt >= 0); const Bool_t restrictCentrality = ((lowerCentrality >= -1) && (upperCentrality >= -1)); for (Int_t species = 0; species < AliPID::kSPECIES; species++) { const TString sparseName = Form("fPtResolution_%s", AliPID::ParticleShortName(species)); hPtResolutionRaw[species] = (THnSparse*)histList->FindObject(sparseName.Data()); if (!hPtResolutionRaw[species]) { printf("Failed to load THnSparse for %s: %s!\n", AliPID::ParticleShortName(species), sparseName.Data()); return -1; } // Set proper errors, if not yet calculated if (!hPtResolutionRaw[species]->GetCalculateErrors()) { std::cout << "Re-calculating errors of " << hPtResolutionRaw[species]->GetName() << "..." << std::endl; hPtResolutionRaw[species]->Sumw2(); Long64_t nBinsPtResolutionRaw = hPtResolutionRaw[species]->GetNbins(); Double_t binContent = 0; for (Long64_t bin = 0; bin < nBinsPtResolutionRaw; bin++) { binContent = hPtResolutionRaw[species]->GetBinContent(bin); hPtResolutionRaw[species]->SetBinError(bin, TMath::Sqrt(binContent)); } } // Integral(lowerCentBinLimit, uppCentBinLimit) will not be restricted if these values are kept const Int_t lowerCentralityBinLimit = restrictCentrality ? hPtResolutionRaw[species]->GetAxis(kPtResCentrality)->FindBin(lowerCentrality + 0.001) : -1; const Int_t upperCentralityBinLimit = restrictCentrality ? hPtResolutionRaw[species]->GetAxis(kPtResCentrality)->FindBin(upperCentrality - 0.001) : -2; if (restrictCentrality) { actualLowerCentrality = hPtResolutionRaw[species]->GetAxis(kPtResCentrality)->GetBinLowEdge(lowerCentralityBinLimit); actualUpperCentrality = hPtResolutionRaw[species]->GetAxis(kPtResCentrality)->GetBinLowEdge(upperCentralityBinLimit); hPtResolutionRaw[species]->GetAxis(kPtResCentrality)->SetRange(lowerCentralityBinLimit, upperCentralityBinLimit); } const Bool_t restrictCharge = (chargeMode != kAllCharged); Int_t lowerChargeBinLimit = -1; Int_t upperChargeBinLimit = -2; if (restrictCharge) { // Add subtract a very small number to avoid problems with values right on the border between to bins if (chargeMode == kNegCharge) { lowerChargeBinLimit = hPtResolutionRaw[species]->GetAxis(kPtResCharge)->FindBin(-1. + 0.001); upperChargeBinLimit = hPtResolutionRaw[species]->GetAxis(kPtResCharge)->FindBin(0. - 0.001); } else if (chargeMode == kPosCharge) { lowerChargeBinLimit = hPtResolutionRaw[species]->GetAxis(kPtResCharge)->FindBin(0. + 0.001); upperChargeBinLimit = hPtResolutionRaw[species]->GetAxis(kPtResCharge)->FindBin(1. - 0.001); } // Check if the values look reasonable if (lowerChargeBinLimit <= upperChargeBinLimit && lowerChargeBinLimit >= 1 && upperChargeBinLimit <= hPtResolutionRaw[species]->GetAxis(kPtResCharge)->GetNbins()) { // OK } else { std::cout << std::endl; std::cout << "Requested charge range out of limits or upper and lower limit are switched!" << std::endl; return -1; } hPtResolutionRaw[species]->GetAxis(kPtResCharge)->SetRange(lowerChargeBinLimit, upperChargeBinLimit); } // If desired, restrict jetPt axis Int_t lowerJetPtBinLimit = -1; Int_t upperJetPtBinLimit = -1; if (restrictJetPtAxis) { // Add subtract a very small number to avoid problems with values right on the border between to bins lowerJetPtBinLimit = hPtResolutionRaw[species]->GetAxis(kPtResJetPt)->FindBin(lowerJetPt + 0.001); upperJetPtBinLimit = hPtResolutionRaw[species]->GetAxis(kPtResJetPt)->FindBin(upperJetPt - 0.001); // Check if the values look reasonable if (lowerJetPtBinLimit <= upperJetPtBinLimit && lowerJetPtBinLimit >= 1 && upperJetPtBinLimit <= hPtResolutionRaw[species]->GetAxis(kPtResJetPt)->GetNbins()) { actualLowerJetPt = hPtResolutionRaw[species]->GetAxis(kPtResJetPt)->GetBinLowEdge(lowerJetPtBinLimit); actualUpperJetPt = hPtResolutionRaw[species]->GetAxis(kPtResJetPt)->GetBinUpEdge(upperJetPtBinLimit); restrictJetPtAxis = kTRUE; } else { std::cout << std::endl; std::cout << "Requested jet pT range out of limits or upper and lower limit are switched!" << std::endl; return -1; } } std::cout << "jet pT: "; if (restrictJetPtAxis) { std::cout << actualLowerJetPt << " - " << actualUpperJetPt << std::endl; hPtResolutionRaw[species]->GetAxis(kPtResJetPt)->SetRange(lowerJetPtBinLimit, upperJetPtBinLimit); } else { std::cout << "All" << std::endl; } hPtResolution[species] = hPtResolutionRaw[species]->Projection(kPtResGenPt, kPtResRecPt, "e"); hPtResolution[species]->SetName(Form("hPtResolution_%s", AliPID::ParticleShortName(species))); hPtResolution[species]->SetTitle(Form("%s", AliPID::ParticleLatexName(species))); hPtResolution[species]->SetStats(kFALSE); hPtResolution[species]->SetLineColor(getLineColorAliPID(species)); hPtResolution[species]->SetMarkerColor(getLineColorAliPID(species)); normaliseHist(hPtResolution[species]); TObjArray aSlices; hPtResolution[species]->FitSlicesY(0, 0, -1, 0, "QNR", &aSlices); TH1D* hMean = (TH1D*)(aSlices.At(1)); TH1D* hSigma = (TH1D*)(aSlices.At(2)); hPtResolutionFit[species] = new TH1D(*hSigma); hPtResolutionFit[species]->SetName(Form("hPtResolutionFit_%s", AliPID::ParticleShortName(species))); hPtResolutionFit[species]->SetTitle(Form("%s", AliPID::ParticleLatexName(species))); hPtResolutionFit[species]->SetLineColor(getLineColorAliPID(species)); hPtResolutionFit[species]->SetMarkerColor(getLineColorAliPID(species)); hPtResolutionFit[species]->Divide(hSigma, hMean); } // Save results to file TString chargeString = ""; if (chargeMode == kPosCharge) chargeString = "_posCharge"; else if (chargeMode == kNegCharge) chargeString = "_negCharge"; TString saveFileName = pathNameData; saveFileName.Replace(0, pathNameData.Last('/') + 1, ""); TString savePath = pathNameData; savePath.ReplaceAll(Form("/%s", saveFileName.Data()), ""); saveFileName.Prepend("output_extractedPTResolution_"); TString centralityString = restrictCentrality ? Form("_centrality_%.0f_%.0f.root", actualLowerCentrality, actualUpperCentrality) : "_centrality_all"; TString jetPtString = restrictJetPtAxis ? Form("_jetPt_%.0f_%.0f.root", actualLowerJetPt, actualUpperJetPt) : ""; saveFileName.ReplaceAll(".root", Form("%s%s%s.root", centralityString.Data(), jetPtString.Data(), chargeString.Data())); TString saveFilePathName = Form("%s/%s", savePath.Data(), saveFileName.Data()); TFile* saveFile = TFile::Open(saveFilePathName.Data(), "RECREATE"); if (!saveFile) { printf("Failed to save results to file \"%s\"!\n", saveFilePathName.Data()); return -1; } saveFile->cd(); for (Int_t species = 0; species < AliPID::kSPECIES; species++) { if (hPtResolution[species]) hPtResolution[species]->Write(); if (hPtResolutionFit[species]) hPtResolutionFit[species]->Write(); } TNamed* settings = new TNamed( Form("Settings: Data file \"%s\", lowerCentrality %.3f, upperCentrality %.3f, lowerJetPt %.1f, upperJetPt %.1f\n", pathNameData.Data(), lowerCentrality, upperCentrality, lowerJetPt, upperJetPt), ""); settings->Write(); saveFile->Close(); return 0; }