{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Introduction\n", "\n", "QA plots for the generic tracking performance" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:21:58.825233Z", "iopub.status.busy": "2025-03-25T16:21:58.824804Z", "iopub.status.idle": "2025-03-25T16:21:58.830734Z", "shell.execute_reply": "2025-03-25T16:21:58.829861Z" } }, "outputs": [], "source": [ "# imports to write dynamic markdown contents\n", "import os\n", "from IPython.display import display, Markdown, Latex\n", "from IPython.display import HTML" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:21:58.833960Z", "iopub.status.busy": "2025-03-25T16:21:58.833516Z", "iopub.status.idle": "2025-03-25T16:21:58.847362Z", "shell.execute_reply": "2025-03-25T16:21:58.846283Z" } }, "outputs": [ { "data": { "text/markdown": [ "*For the result HTML page:* " ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "\n", "
" ], "text/plain": [ "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# turn off/on code for the result HTML page\n", "\n", "display(Markdown('*For the result HTML page:* '))\n", " \n", "HTML('''\n", "
''')" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:21:58.891455Z", "iopub.status.busy": "2025-03-25T16:21:58.890993Z", "iopub.status.idle": "2025-03-25T16:21:58.898242Z", "shell.execute_reply": "2025-03-25T16:21:58.897389Z" } }, "outputs": [ { "data": { "text/markdown": [ "[//]: # (This section starts with a 2nd level heading and get embedded in the result QA report at https://github.com/sPHENIX-Collaboration/QA-gallery/tree/QA-tracking-pythiajet)\n", "\n", "## Tracking QA with high pT Pythia events\n", "\n", "PYTHIA high $p_T$ tracking QA consists full tracker + reconstruction of events with the default Pythia configuration file. This cfg file has a single hard QCD ccbar event with minimum partonic $p_T$ of 10 GeV and truth jet triggering of $p_T>20$ GeV. \n", "\n", "Last a D0->piK filter is applied so the same sample canbe used in D0 reco validation. Please note the calorimeters are disabled to improve execution speed, which also removed some of the correlated albedo background for the tracker. \n", "\n", "In addition to the Pythia event, an Upsilon is embedded to probe an agregated tracking resolution. \n", "\n", "The source code of the macro can be found at https://github.com/sPHENIX-Collaboration/macros/tree/QA-tracking-pythiajet or [comparing it to the master branch](https://github.com/sPHENIX-Collaboration/macros/compare/QA-tracking-pythiajet?expand=1).\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import os.path\n", "\n", "# readme file of the macros, available if run under JenkinsCI\n", "# https://github.com/sPHENIX-Collaboration/utilities/blob/master/jenkins/built-test/test-tracking-qa.sh \n", "\n", "macro_markdown = 'Fun4All-macros-README.md'\n", "\n", "\n", "if os.path.isfile(macro_markdown) :\n", " with open(macro_markdown, 'r') as file:\n", " display(Markdown(file.read()))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## `pyROOT` env check" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:21:58.901479Z", "iopub.status.busy": "2025-03-25T16:21:58.901018Z", "iopub.status.idle": "2025-03-25T16:22:07.998524Z", "shell.execute_reply": "2025-03-25T16:22:07.996684Z" }, "tags": [] }, "outputs": [ { "data": { "text/markdown": [ "via sPHENIX software distribution at `/var/lib/jenkins/workspace/sPHENIX/Build-Master-gcc14/build/new/install.1`" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import ROOT\n", "\n", "OFFLINE_MAIN = os.getenv(\"OFFLINE_MAIN\")\n", "if OFFLINE_MAIN is not None:\n", " display(Markdown(f\"via sPHENIX software distribution at `{OFFLINE_MAIN}`\"))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plotting source code" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:08.002667Z", "iopub.status.busy": "2025-03-25T16:22:08.002165Z", "iopub.status.idle": "2025-03-25T16:22:08.132876Z", "shell.execute_reply": "2025-03-25T16:22:08.131591Z" } }, "outputs": [ { "data": { "text/markdown": [ "View the source code repository at https://github.com/sPHENIX-Collaboration/QA-gallery.git" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import subprocess\n", "\n", "try:\n", " git_url = \\\n", " subprocess.run(['git','remote','get-url','origin'], stdout=subprocess.PIPE)\\\n", " .stdout.decode('utf-8').strip()\\\n", " .replace('git@github.com:','https://github.com/')\n", "\n", " display(Markdown(f\"View the source code repository at {git_url}\"))\n", "except: # catch *all* exceptions\n", " # well do nothing\n", " pass" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## JenkinsCI information (if available)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:08.136287Z", "iopub.status.busy": "2025-03-25T16:22:08.135945Z", "iopub.status.idle": "2025-03-25T16:22:08.260088Z", "shell.execute_reply": "2025-03-25T16:22:08.259270Z" } }, "outputs": [ { "data": { "text/markdown": [ "Some further details about the QA run, if executed under the Jenkins CI:" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/markdown": [ "* The commit being checked is sPHENIX-Collaboration/coresoftware/cdd9aff0a42f7fc7812a7e49161bae9e18b1bfb3" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/markdown": [ "* Link to the pull request: https://github.com/sPHENIX-Collaboration/coresoftware/pull/3493" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/markdown": [ "* Link to the build: https://web.sdcc.bnl.gov/jenkins-sphenix/job/sPHENIX/job/test-tracking-pythiajet-qa/5343/" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/markdown": [ "* Git repo for macros: https://github.com/sPHENIX-Collaboration/macros.git , which merges `master` and the QA tracking branch" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/markdown": [ "* Download the QA ROOT files: https://web.sdcc.bnl.gov/jenkins-sphenix/job/sPHENIX/job/test-tracking-pythiajet-qa/5343/display/redirect?page=artifacts" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/markdown": [ "Automatically generated by [sPHENIX Jenkins continuous integration](https://web.sdcc.bnl.gov/jenkins-sphenix/) [![sPHENIX](https://raw.githubusercontent.com/sPHENIX-Collaboration/utilities/master/jenkins/material/sphenix-logo-white-bg-72p.png)](https://www.sphenix.bnl.gov/web/)             [![jenkins.io](https://raw.githubusercontent.com/sPHENIX-Collaboration/utilities/master/jenkins/material/jenkins_logo_title-72p.png)](https://jenkins.io/)" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "display(Markdown('Some further details about the QA run, if executed under the Jenkins CI:'))\n", "\n", "checkrun_repo_commit = os.getenv(\"checkrun_repo_commit\")\n", "if checkrun_repo_commit is not None:\n", " display(Markdown(f\"* The commit being checked is {checkrun_repo_commit}\"))\n", " \n", "ghprbPullLink = os.getenv(\"ghprbPullLink\")\n", "if ghprbPullLink is not None:\n", " display(Markdown(f\"* Link to the pull request: {ghprbPullLink}\"))\n", "\n", "BUILD_URL = os.getenv(\"BUILD_URL\")\n", "if BUILD_URL is not None:\n", " display(Markdown(f\"* Link to the build: {BUILD_URL}\"))\n", "\n", "git_url_macros = os.getenv(\"git_url_macros\")\n", "sha_macros = os.getenv(\"sha_macros\")\n", "if git_url_macros is not None:\n", " display(Markdown(f\"* Git repo for macros: {git_url_macros} , which merges `{sha_macros}` and the QA tracking branch\"))\n", "\n", "RUN_ARTIFACTS_DISPLAY_URL = os.getenv(\"RUN_ARTIFACTS_DISPLAY_URL\")\n", "if RUN_ARTIFACTS_DISPLAY_URL is not None:\n", " display(Markdown(f\"* Download the QA ROOT files: {RUN_ARTIFACTS_DISPLAY_URL}\"))\n", "\n", "JENKINS_URL = os.getenv(\"JENKINS_URL\")\n", "if JENKINS_URL is not None:\n", " display(Markdown(f\"Automatically generated by [sPHENIX Jenkins continuous integration]({JENKINS_URL}) [![sPHENIX](https://raw.githubusercontent.com/sPHENIX-Collaboration/utilities/master/jenkins/material/sphenix-logo-white-bg-72p.png)](https://www.sphenix.bnl.gov/web/)             [![jenkins.io](https://raw.githubusercontent.com/sPHENIX-Collaboration/utilities/master/jenkins/material/jenkins_logo_title-72p.png)](https://jenkins.io/)\"))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "# Initialization" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:08.263127Z", "iopub.status.busy": "2025-03-25T16:22:08.262814Z", "iopub.status.idle": "2025-03-25T16:22:08.875209Z", "shell.execute_reply": "2025-03-25T16:22:08.873787Z" }, "scrolled": true }, "outputs": [], "source": [ "%%cpp -d\n", "\n", "#include \"QA_Draw_Utility.C\"\n", "\n", "#include \n", "\n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include " ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:08.879947Z", "iopub.status.busy": "2025-03-25T16:22:08.879315Z", "iopub.status.idle": "2025-03-25T16:22:09.763692Z", "shell.execute_reply": "2025-03-25T16:22:09.762523Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "sPhenixStyle: Applying nominal settings.\n", "sPhenixStyle: ROOT6 mode\n" ] } ], "source": [ "%%cpp\n", "\n", "SetsPhenixStyle();\n", "TVirtualFitter::SetDefaultFitter(\"Minuit2\");\n", "\n", "// test sPHENIX lib load\n", "// gSystem->Load(\"libg4eval.so\");\n", "\n", "// test libs\n", "// gSystem->ListLibraries();" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:09.767016Z", "iopub.status.busy": "2025-03-25T16:22:09.766445Z", "iopub.status.idle": "2025-03-25T16:22:09.920751Z", "shell.execute_reply": "2025-03-25T16:22:09.919977Z" } }, "outputs": [], "source": [ "%jsroot on" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Inputs and file checks" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:09.923446Z", "iopub.status.busy": "2025-03-25T16:22:09.923229Z", "iopub.status.idle": "2025-03-25T16:22:10.029902Z", "shell.execute_reply": "2025-03-25T16:22:10.028881Z" } }, "outputs": [], "source": [ "\n", "qa_file_name_new = os.getenv(\"qa_file_name_new\")\n", "if qa_file_name_new is None:\n", " qa_file_name_new = \"G4sPHENIX_test-tracking-low-occupancy-qa_Event100_Sum10_qa.root\"\n", " display(Markdown(f\"`qa_file_name_new` env not set. use the default `qa_file_name_new={qa_file_name_new}`\"))\n", "\n", "qa_file_name_ref = os.getenv(\"qa_file_name_ref\")\n", "if qa_file_name_ref is None:\n", " qa_file_name_ref = \"reference/G4sPHENIX_test-tracking-low-occupancy-qa_Event100_Sum10_qa.root\"\n", " display(Markdown(f\"`qa_file_name_ref` env not set. use the default `qa_file_name_ref={qa_file_name_ref}`\"))\n", "elif qa_file_name_ref == 'None':\n", " qa_file_name_ref = None\n", " display(Markdown(f\"`qa_file_name_ref` = None and we are set to not to use the reference histograms\"))\n", " \n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:10.033685Z", "iopub.status.busy": "2025-03-25T16:22:10.033385Z", "iopub.status.idle": "2025-03-25T16:22:10.225099Z", "shell.execute_reply": "2025-03-25T16:22:10.223840Z" } }, "outputs": [ { "data": { "text/markdown": [ "Opening QA file at `G4sPHENIX_test-tracking_Event550_Sum10_qa.root`" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/markdown": [ "Opening QA reference file at `reference/G4sPHENIX_test-tracking_Event550_Sum10_qa.root`" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# qa_file_new = ROOT.TFile.Open(qa_file_name_new);\n", "\n", "# assert qa_file_new.IsOpen()\n", "# qa_file_new.ls()\n", "display(Markdown(f\"Opening QA file at `{qa_file_name_new}`\"))\n", "ROOT.gInterpreter.ProcessLine(f\"TFile *qa_file_new = new TFile(\\\"{qa_file_name_new}\\\");\")\n", "ROOT.gInterpreter.ProcessLine(f\"const char * qa_file_name_new = \\\"{qa_file_name_new}\\\";\")\n", "\n", "if qa_file_name_ref is not None:\n", "# qa_file_ref = ROOT.TFile.Open(qa_file_name_ref);\n", "\n", "# assert qa_file_ref.IsOpen()\n", " display(Markdown(f\"Opening QA reference file at `{qa_file_name_ref}`\"))\n", " ROOT.gInterpreter.ProcessLine(f\"TFile *qa_file_ref = new TFile(\\\"{qa_file_name_ref}\\\");\")\n", " ROOT.gInterpreter.ProcessLine(f\"const char * qa_file_name_ref = \\\"{qa_file_name_ref}\\\";\")\n", "else:\n", " ROOT.gInterpreter.ProcessLine(f\"TFile *qa_file_ref = nullptr;\")\n", " ROOT.gInterpreter.ProcessLine(f\"const char * qa_file_name_ref = nullptr;\")\n" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:10.229256Z", "iopub.status.busy": "2025-03-25T16:22:10.228912Z", "iopub.status.idle": "2025-03-25T16:22:10.352761Z", "shell.execute_reply": "2025-03-25T16:22:10.351697Z" }, "scrolled": true }, "outputs": [], "source": [ "%%cpp\n", "\n", "if (qa_file_new == nullptr) \n", "{\n", " cout <<\"Error, can not open QA root file\"<ls();\n", "\n", "//TFile *qa_file_ref = NULL;\n", "//if (qa_file_name_ref)\n", "//{\n", "// qa_file_ref = new TFile(qa_file_name_ref);\n", "// \n", "// if (qa_file_ref == nullptr) \n", "// {\n", "// cout <<\"Error, can not open QA root file\"<\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "{\n", " const char *hist_name_prefix = \"QAG4SimulationTracking\";\n", " TString prefix = TString(\"h_\") + hist_name_prefix + TString(\"_\");\n", " \n", " TCanvas *rawResCan = new TCanvas(TString(\"QA_Draw_pTResolution\") + TString(\"_\") + hist_name_prefix,\n", " TString(\"QA_Draw_pTResolution\") + TString(\"_\") + hist_name_prefix,\n", " 900,500);\n", " rawResCan->Divide(2,2);\n", " \n", " TH2F *h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_new =\n", " (TH2F *)qa_file_new->GetObjectChecked(prefix + \"pTRecoGenRatio_pTGen\",\n", " \"TH2\");\n", " assert(h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_new);\n", " \n", " h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_new->SetDirectory(nullptr);\n", " \n", " TGraphErrors *newScale = FitResolution(h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_new, false, 1);\n", " TGraphErrors *newRes = FitResolution(h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_new, false, 2);\n", " newScale->SetMarkerStyle(20);\n", " newScale->SetMarkerColor(kBlack);\n", " newScale->SetMarkerSize(1.0);\n", " newRes->SetMarkerStyle(20);\n", " newRes->SetMarkerColor(kBlack);\n", " newRes->SetMarkerSize(1.0);\n", " \n", " rawResCan->cd(3);\n", " newScale->GetXaxis()->SetTitle(\"Truth p_{T} [GeV]\");\n", " newScale->GetYaxis()->SetTitle(\"#LTp_{T}^{reco}/p_{T}^{true}#GT\");\n", " newScale->GetYaxis()->SetRangeUser(0.9,1.1);\n", " newScale->Draw(\"ap\");\n", " \n", " rawResCan->cd(4);\n", " newRes->GetXaxis()->SetTitle(\"Truth p_{T} [GeV]\");\n", " newRes->GetYaxis()->SetTitle(\"#sigma(p_{T}^{reco}/p_{T}^{true})\");\n", " newRes->GetYaxis()->SetRangeUser(0,0.08);\n", " newRes->Draw(\"ap\");\n", " \n", " rawResCan->cd(2);\n", " gPad->SetRightMargin(0.2);\n", " gPad->SetLogx();\n", " gPad->SetLogz();\n", " h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_new->SetTitle(\"New pT Spectrum\");\n", " h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_new->Draw(\"colz\");\n", " \n", " TLatex newl; \n", " newl.SetTextSize(0.05); \n", " newl.SetNDC();\n", " newl.SetTextColor(kBlack);\n", " newl.DrawLatex(0.45,0.96,\"New\");\n", " \n", " if (qa_file_ref) {\n", " TH2F *h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_ref =\n", " (TH2F *)qa_file_ref->GetObjectChecked(prefix + \"pTRecoGenRatio_pTGen\",\n", " \"TH2\");\n", " assert(h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_ref);\n", " h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_ref->SetDirectory(nullptr);\n", " \n", " TGraphErrors *refScale = FitResolution(h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_ref, false, 1);\n", " TGraphErrors *refRes = FitResolution(h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_ref, false, 2);\n", " refScale->SetMarkerStyle(24);\n", " refScale->SetMarkerColor(kRed);\n", " refScale->SetMarkerSize(1.0);\n", " refRes->SetMarkerStyle(24);\n", " refRes->SetMarkerColor(kRed);\n", " refRes->SetMarkerSize(1.0);\n", " \n", " TLegend *ptresleg = new TLegend(0.4,0.77,0.5,0.9);\n", " ptresleg->AddEntry(refScale,\"Reference\",\"P\");\n", " ptresleg->AddEntry(newScale,\"New\",\"P\"); \n", " \n", " rawResCan->cd(3);\n", " refScale->Draw(\"psame\");\n", " ptresleg->Draw(\"same\");\n", " \n", " rawResCan->cd(4);\n", " refRes->Draw(\"psame\");\n", " ptresleg->Draw(\"same\"); \n", " \n", " rawResCan->cd(1);\n", " \n", " gPad->SetRightMargin(0.2);\n", " gPad->SetLogx();\n", " gPad->SetLogz();\n", " h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_ref->SetTitle(\"Reference pT Spectrum\");\n", " h_QAG4SimulationTracking_pTRecoGenRatio_pTGen_ref->Draw(\"colz\");\n", " TLatex refl; \n", " refl.SetTextSize(0.05); \n", " refl.SetNDC();\n", " refl.SetTextColor(kBlack);\n", " refl.DrawLatex(0.45,0.96,\"Reference\");\n", " \n", " }\n", " \n", " rawResCan->Draw();\n", " \n", " \n", "}\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:11.555573Z", "iopub.status.busy": "2025-03-25T16:22:11.555097Z", "iopub.status.idle": "2025-03-25T16:22:11.669192Z", "shell.execute_reply": "2025-03-25T16:22:11.668308Z" } }, "outputs": [], "source": [ "%jsroot off" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:11.672316Z", "iopub.status.busy": "2025-03-25T16:22:11.671902Z", "iopub.status.idle": "2025-03-25T16:22:12.083627Z", "shell.execute_reply": "2025-03-25T16:22:12.082666Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "\n", "{\n", " //base histogram from the reco module name \n", " const char *hist_name_prefix = \"QAG4SimulationTracking\";\n", " TString prefix = TString(\"h_\") + hist_name_prefix + TString(\"_\");\n", " \n", " // obtain normalization\n", " double Nevent_new = 1;\n", " double Nevent_ref = 1;\n", "\n", " TCanvas *c1 = new TCanvas(TString(\"QA_Draw_Tracking_TruthMatchingOverview\") +\n", " TString(\"_\") + hist_name_prefix,\n", " TString(\"QA_Draw_Tracking_TruthMatchingOverview\") +\n", " TString(\"_\") + hist_name_prefix,\n", " 900, 400);\n", " c1->Divide(3, 1);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " {\n", " static const int nrebin = 5;\n", "\n", " p = (TPad *)c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetGridy();\n", "\n", " TH1 *h_pass =\n", " (TH1 *)qa_file_new->GetObjectChecked(prefix + \"nReco_pTGen\", \"TH1\");\n", " TH1 *h_norm =\n", " (TH1 *)qa_file_new->GetObjectChecked(prefix + \"nGen_pTGen\", \"TH1\");\n", " assert(h_norm);\n", " assert(h_pass);\n", " \n", " h_norm->SetDirectory(nullptr);\n", " h_pass->SetDirectory(nullptr);\n", "\n", " h_norm->Rebin(nrebin);\n", " h_pass->Rebin(nrebin);\n", "\n", " TH1 *h_ratio = GetBinominalRatio(h_pass, h_norm);\n", "\n", " // h_ratio->GetXaxis()->SetRangeUser(min_Et, max_Et);\n", " h_ratio->GetYaxis()->SetTitle(\"Reco efficiency\");\n", " h_ratio->GetYaxis()->SetRangeUser(-0, 1.);\n", "\n", " TH1 *h_ratio_ref = NULL;\n", " if (qa_file_ref) {\n", " TH1 *h_pass =\n", " (TH1 *)qa_file_ref->GetObjectChecked(prefix + \"nReco_pTGen\", \"TH1\");\n", " TH1 *h_norm =\n", " (TH1 *)qa_file_ref->GetObjectChecked(prefix + \"nGen_pTGen\", \"TH1\");\n", " assert(h_norm);\n", " assert(h_pass);\n", " h_norm->SetDirectory(nullptr);\n", " h_pass->SetDirectory(nullptr);\n", " h_norm->Rebin(nrebin);\n", " h_pass->Rebin(nrebin);\n", " h_ratio_ref = GetBinominalRatio(h_pass, h_norm);\n", " }\n", "\n", " h_ratio->SetTitle(TString(hist_name_prefix) + \": Tracking Efficiency\");\n", "\n", " DrawReference(h_ratio, h_ratio_ref, false);\n", " }\n", "\n", " {\n", " static const int nrebin = 4;\n", "\n", " p = (TPad *)c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " p->SetGridy();\n", "\n", " TH1 *h_pass =\n", " (TH1 *)qa_file_new->GetObjectChecked(prefix + \"nReco_etaGen\", \"TH1\");\n", " TH1 *h_norm =\n", " (TH1 *)qa_file_new->GetObjectChecked(prefix + \"nGen_etaGen\", \"TH1\");\n", " assert(h_norm);\n", " assert(h_pass);\n", "\n", " h_norm->SetDirectory(nullptr);\n", " h_pass->SetDirectory(nullptr);\n", " h_norm->Rebin(nrebin);\n", " h_pass->Rebin(nrebin);\n", "\n", " TH1 *h_ratio = GetBinominalRatio(h_pass, h_norm);\n", "\n", " h_ratio->GetXaxis()->SetRangeUser(-1.1, 1.1);\n", " h_ratio->GetYaxis()->SetTitle(\"Reco efficiency\");\n", " h_ratio->GetYaxis()->SetRangeUser(-0, 1.);\n", "\n", " TH1 *h_ratio_ref = NULL;\n", " if (qa_file_ref) {\n", " TH1 *h_pass =\n", " (TH1 *)qa_file_ref->GetObjectChecked(prefix + \"nReco_etaGen\", \"TH1\");\n", " TH1 *h_norm =\n", " (TH1 *)qa_file_ref->GetObjectChecked(prefix + \"nGen_etaGen\", \"TH1\");\n", " assert(h_norm);\n", " assert(h_pass);\n", " h_norm->SetDirectory(nullptr);\n", " h_pass->SetDirectory(nullptr);\n", " h_norm->Rebin(nrebin);\n", " h_pass->Rebin(nrebin);\n", " h_ratio_ref = GetBinominalRatio(h_pass, h_norm);\n", " }\n", "\n", " h_ratio->SetTitle(TString(hist_name_prefix) + \": Tracking Efficiency\");\n", "\n", " DrawReference(h_ratio, h_ratio_ref, false);\n", " }\n", "\n", " {\n", " p = (TPad *)c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " TH1 *frame = p->DrawFrame(0, .9, 50, 1.1,\n", " \"Mean and sigma, p_{T,reco}/p_{T,truth};Truth p_{T} [GeV/c]; #pm #sigma(p_{T,reco}/p_{T,truth})\");\n", " //gPad->SetLeftMargin(.2);\n", " gPad->SetTopMargin(-1);\n", " frame->GetYaxis()->SetTitleOffset(1.7);\n", " //TLine *l = new TLine(0, 1, 50, 1);\n", " //l->SetLineColor(kGray);\n", " //l->Draw();\n", " HorizontalLine( gPad, 1 )->Draw();\n", "\n", " TH2 *h_QAG4SimulationTracking_pTRecoGenRatio_pTGen =\n", " (TH2 *)qa_file_new->GetObjectChecked(prefix + \"pTRecoGenRatio_pTGen\",\n", " \"TH2\");\n", " assert(h_QAG4SimulationTracking_pTRecoGenRatio_pTGen);\n", "\n", " h_QAG4SimulationTracking_pTRecoGenRatio_pTGen->SetDirectory(nullptr);\n", " h_QAG4SimulationTracking_pTRecoGenRatio_pTGen->Rebin2D(16, 1);\n", " TGraphErrors *ge_QAG4SimulationTracking_pTRecoGenRatio_pTGen =\n", " FitProfile(h_QAG4SimulationTracking_pTRecoGenRatio_pTGen);\n", " ge_QAG4SimulationTracking_pTRecoGenRatio_pTGen->Draw(\"pe\");\n", " ge_QAG4SimulationTracking_pTRecoGenRatio_pTGen->SetTitle(\n", " \"Mean and sigma, p_{T,reco}/p_{T,truth}\");\n", "\n", " TGraphErrors *h_ratio_ref = NULL;\n", " if (qa_file_ref) {\n", " TH2 *h_QAG4SimulationTracking_pTRecoGenRatio_pTGen =\n", " (TH2 *)qa_file_ref->GetObjectChecked(prefix + \"pTRecoGenRatio_pTGen\",\n", " \"TH2\");\n", " assert(h_QAG4SimulationTracking_pTRecoGenRatio_pTGen);\n", "\n", " h_QAG4SimulationTracking_pTRecoGenRatio_pTGen->SetDirectory(nullptr);\n", " h_QAG4SimulationTracking_pTRecoGenRatio_pTGen->Rebin2D(16, 1);\n", "\n", " h_ratio_ref = FitProfile(h_QAG4SimulationTracking_pTRecoGenRatio_pTGen);\n", " ge_QAG4SimulationTracking_pTRecoGenRatio_pTGen->Draw(\"pe\");\n", " }\n", "\n", " DrawReference(ge_QAG4SimulationTracking_pTRecoGenRatio_pTGen, h_ratio_ref,\n", " true);\n", " \n", " SaveGraphError2CSV(ge_QAG4SimulationTracking_pTRecoGenRatio_pTGen, \"QAG4SimulationTracking_pTRecoGenRatio_pTGen\");\n", " }\n", "\n", " //SaveCanvas(c1,\n", " // TString(qa_file_name_new) + TString(\"_\") + TString(c1->GetName()),\n", " // true);\n", " \n", " c1->Draw();\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# $p_T$ resolution and lineshape" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:12.087324Z", "iopub.status.busy": "2025-03-25T16:22:12.086892Z", "iopub.status.idle": "2025-03-25T16:22:12.194436Z", "shell.execute_reply": "2025-03-25T16:22:12.193486Z" } }, "outputs": [], "source": [ "%jsroot on" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:12.198158Z", "iopub.status.busy": "2025-03-25T16:22:12.197591Z", "iopub.status.idle": "2025-03-25T16:22:12.541931Z", "shell.execute_reply": "2025-03-25T16:22:12.540928Z" } }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "
\n", "
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "\n", "{\n", " const char *hist_name_prefix = \"QAG4SimulationTracking\";\n", " TString prefix = TString(\"h_\") + hist_name_prefix + TString(\"_\");\n", " \n", " // obtain normalization\n", " double Nevent_new = 1;\n", " double Nevent_ref = 1;\n", " \n", " \n", " TH2 *h_new = (TH2 *) qa_file_new->GetObjectChecked(\n", " prefix + TString(\"pTRecoGenRatio_pTGen\"), \"TH2\");\n", " assert(h_new);\n", "\n", " // h_new->Rebin(1, 2);\n", " //h_new->Sumw2();\n", " // h_new->Scale(1. / Nevent_new);\n", "\n", " TH2 *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH2 *) qa_file_ref->GetObjectChecked(\n", " prefix + TString(\"pTRecoGenRatio_pTGen\"), \"TH2\");\n", " assert(h_ref);\n", "\n", " // h_ref->Rebin(1, 2);\n", " //h_ref->Sumw2();\n", " h_ref->Scale(Nevent_new / Nevent_ref);\n", " }\n", "\n", " TCanvas *c1 = new TCanvas(TString(\"QA_Draw_Tracking_pTRatio\") + TString(\"_\") + hist_name_prefix,\n", " TString(\"QA_Draw_Tracking_pTRatio\") + TString(\"_\") + hist_name_prefix,\n", " 950, 600);\n", " c1->Divide(4, 2);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " vector> gpt_ranges{\n", " {0, 1},\n", " {1, 5},\n", " {5, 10},\n", " {10, 15},\n", " {15, 50}};\n", " TF1 *f1 = nullptr;\n", " TF1 *fit = nullptr;\n", " Double_t sigma = 0;\n", " Double_t sigma_unc = 0;\n", " char resstr[500];\n", " TLatex *res = nullptr;\n", " for (auto pt_range : gpt_ranges)\n", " {\n", " //cout << __PRETTY_FUNCTION__ << \" process \" << pt_range.first << \" - \" << pt_range.second << \" GeV/c\";\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " const double epsilon = 1e-6;\n", " const int bin_start = h_new->GetXaxis()->FindBin(pt_range.first + epsilon);\n", " const int bin_end = h_new->GetXaxis()->FindBin(pt_range.second - epsilon);\n", "\n", " TH1 *h_proj_new = h_new->ProjectionY(\n", " TString::Format(\n", " \"%s_New_ProjX_%d_%d\",\n", " h_new->GetName(), bin_start, bin_end),\n", " bin_start, bin_end);\n", "\n", " h_proj_new->GetXaxis()->SetRangeUser(.7, 1.3);\n", " h_proj_new->SetTitle(TString(hist_name_prefix) + TString::Format(\n", " \": %.1f - %.1f GeV/c\", pt_range.first, pt_range.second));\n", " h_proj_new->GetXaxis()->SetTitle(TString::Format(\n", " \"Reco p_{T}/Truth p_{T}\"));\n", "\n", " f1 = new TF1(\"f1\", \"gaus\", -.85, 1.15);\n", " h_proj_new->Fit(f1, \"mq\");\n", " sigma = f1->GetParameter(2);\n", " sigma_unc = f1->GetParError(2);\n", "\n", " TH1 *h_proj_ref = nullptr;\n", " if (h_ref)\n", " h_proj_ref =\n", " h_ref->ProjectionY(\n", " TString::Format(\n", " \"%s_Ref_ProjX_%d_%d\",\n", " h_new->GetName(), bin_start, bin_end),\n", " bin_start, bin_end);\n", "\n", " DrawReference(h_proj_new, h_proj_ref);\n", " sprintf(resstr, \"#sigma = %.5f #pm %.5f\", sigma, sigma_unc);\n", " res = new TLatex(0.325, 0.825, resstr);\n", " res->SetNDC();\n", " res->SetTextSize(0.05);\n", " res->SetTextAlign(13);\n", " res->Draw();\n", " }\n", "\n", " // SaveCanvas(c1, TString(qa_file_name_new) + TString(\"_\") + TString(c1->GetName()), true);\n", " c1->Draw();\n", "}" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:12.547210Z", "iopub.status.busy": "2025-03-25T16:22:12.546685Z", "iopub.status.idle": "2025-03-25T16:22:12.655065Z", "shell.execute_reply": "2025-03-25T16:22:12.654027Z" } }, "outputs": [], "source": [ "%jsroot off" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:12.658488Z", "iopub.status.busy": "2025-03-25T16:22:12.658037Z", "iopub.status.idle": "2025-03-25T16:22:12.964181Z", "shell.execute_reply": "2025-03-25T16:22:12.962771Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "\n", "{\n", "const char *hist_name_prefix = \"QAG4SimulationTracking\";\n", " TString prefix = TString(\"h_\") + hist_name_prefix + TString(\"_\");\n", " \n", " \n", " // obtain normalization\n", " double Nevent_new = 1;\n", " double Nevent_ref = 1;\n", "\n", " if (qa_file_new)\n", " {\n", " //cout << \"Open new QA file \" << qa_file_new->GetName() << endl;\n", "\n", " TH1 *h_norm = (TH1 *) qa_file_new->GetObjectChecked(\n", " prefix + TString(\"Normalization\"), \"TH1\");\n", " assert(h_norm);\n", "\n", " Nevent_new = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " }\n", " if (qa_file_ref)\n", " {\n", " // cout << \"Open ref QA file \" << qa_file_ref->GetName() << endl;\n", " TH1 *h_norm = (TH1 *) qa_file_ref->GetObjectChecked(\n", " prefix + TString(\"Normalization\"), \"TH1\");\n", " assert(h_norm);\n", "\n", " Nevent_ref = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " }\n", " \n", " \n", " TCanvas *c1 = new TCanvas(TString(\"QA_Draw_Tracking_RecoTruthMatching\") +\n", " TString(\"_\") + hist_name_prefix,\n", " TString(\"QA_Draw_Tracking_RecoTruthMatching\") +\n", " TString(\"_\") + hist_name_prefix,\n", " 950, 600);\n", " c1->Divide(2, 1);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " {\n", " static const int nrebin = 5;\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetGridy();\n", "\n", " TH1 *h_pass =\n", " (TH1 *) qa_file_new->GetObjectChecked(prefix + \"nGen_pTReco\", \"TH1\");\n", " TH1 *h_norm =\n", " (TH1 *) qa_file_new->GetObjectChecked(prefix + \"nReco_pTReco\", \"TH1\");\n", " assert(h_norm);\n", " assert(h_pass);\n", " \n", " h_norm->SetDirectory(nullptr);\n", " h_pass->SetDirectory(nullptr);\n", "\n", " h_norm->Rebin(nrebin);\n", " h_pass->Rebin(nrebin);\n", "\n", " TH1 *h_ratio = GetBinominalRatio(h_pass, h_norm);\n", "\n", " // h_ratio->GetXaxis()->SetRangeUser(min_Et, max_Et);\n", " h_ratio->GetYaxis()->SetTitle(\"Tracking Purity\");\n", " h_ratio->GetYaxis()->SetRangeUser(-0, 1.1);\n", "\n", " TH1 *h_ratio_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH1 *h_pass =\n", " (TH1 *) qa_file_ref->GetObjectChecked(prefix + \"nGen_pTReco\", \"TH1\");\n", " TH1 *h_norm =\n", " (TH1 *) qa_file_ref->GetObjectChecked(prefix + \"nReco_pTReco\", \"TH1\");\n", " assert(h_norm);\n", " assert(h_pass);\n", " h_norm->SetDirectory(nullptr);\n", " h_pass->SetDirectory(nullptr);\n", " h_norm->Rebin(nrebin);\n", " h_pass->Rebin(nrebin);\n", " h_ratio_ref = GetBinominalRatio(h_pass, h_norm);\n", " }\n", "\n", " h_ratio->SetTitle(\"Tracking Purity (matched truth-reco pairs)\");\n", "\n", " DrawReference(h_ratio, h_ratio_ref, false);\n", " }\n", "\n", " {\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " TH1 *frame = p->DrawFrame(0, .9, 50, 1.1,\n", " \"Mean and sigma p_{Tmatched}/p_{Treco};Reco p_{T} [GeV/c]; #pm #sigma(p_{T,matched}/p_{T,reco})\");\n", " // gPad->SetLeftMargin(.2);\n", " gPad->SetTopMargin(-1);\n", " frame->GetYaxis()->SetTitleOffset(1.7);\n", " // TLine *l = new TLine(0, 1, 50, 1);\n", " // l->SetLineColor(kGray);\n", " // l->Draw();\n", " HorizontalLine(gPad, 1)->Draw();\n", "\n", " TH2 *h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco =\n", " (TH2 *) qa_file_new->GetObjectChecked(\n", " prefix + \"pTRecoTruthMatchedRatio_pTReco\", \"TH2\");\n", " assert(h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco);\n", "\n", " h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->SetDirectory(nullptr);\n", " h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->Rebin2D(16, 1);\n", "\n", " TGraphErrors *ge_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco =\n", " FitProfile(h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco);\n", " ge_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->Draw(\"pe\");\n", " ge_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->SetTitle(\n", " \"Mean and sigma p_{Tmatched}/p_{Treco}\");\n", "\n", " TGraphErrors *h_ratio_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2 *h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco =\n", " (TH2 *) qa_file_ref->GetObjectChecked(\n", " prefix + \"pTRecoTruthMatchedRatio_pTReco\", \"TH2\");\n", " assert(h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco);\n", "\n", " h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->SetDirectory(nullptr);\n", " h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->Rebin2D(16, 1);\n", "\n", " h_ratio_ref =\n", " FitProfile(h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco);\n", " ge_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->Draw(\"pe\");\n", " }\n", "\n", " DrawReference(ge_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco,\n", " h_ratio_ref, true);\n", "\n", " }\n", "\n", " c1->Draw();\n", "}" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:12.967760Z", "iopub.status.busy": "2025-03-25T16:22:12.967551Z", "iopub.status.idle": "2025-03-25T16:22:13.303883Z", "shell.execute_reply": "2025-03-25T16:22:13.302509Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Warning in : Deleting canvas with same name: QA_Draw_Tracking_RecoTruthMatching_QAG4SimulationTracking\n" ] }, { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "\n", "{\n", "const char *hist_name_prefix = \"QAG4SimulationTracking\";\n", " TString prefix = TString(\"h_\") + hist_name_prefix + TString(\"_\");\n", " \n", " \n", " // obtain normalization\n", " double Nevent_new = 1;\n", " double Nevent_ref = 1;\n", "\n", " if (qa_file_new)\n", " {\n", " //cout << \"Open new QA file \" << qa_file_new->GetName() << endl;\n", "\n", " TH1 *h_norm = (TH1 *) qa_file_new->GetObjectChecked(\n", " prefix + TString(\"Normalization\"), \"TH1\");\n", " assert(h_norm);\n", "\n", " Nevent_new = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " }\n", " if (qa_file_ref)\n", " {\n", " // cout << \"Open ref QA file \" << qa_file_ref->GetName() << endl;\n", " TH1 *h_norm = (TH1 *) qa_file_ref->GetObjectChecked(\n", " prefix + TString(\"Normalization\"), \"TH1\");\n", " assert(h_norm);\n", "\n", " Nevent_ref = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " }\n", " \n", " \n", " TCanvas *c1 = new TCanvas(TString(\"QA_Draw_Tracking_RecoTruthMatching\") +\n", " TString(\"_\") + hist_name_prefix,\n", " TString(\"QA_Draw_Tracking_RecoTruthMatching\") +\n", " TString(\"_\") + hist_name_prefix,\n", " 950, 600);\n", " c1->Divide(2, 1);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " {\n", " static const int nrebin = 5;\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetGridy();\n", "\n", " TH1 *h_pass =\n", " (TH1 *) qa_file_new->GetObjectChecked(prefix + \"nGen_pTReco\", \"TH1\");\n", " TH1 *h_norm =\n", " (TH1 *) qa_file_new->GetObjectChecked(prefix + \"nReco_pTReco\", \"TH1\");\n", " assert(h_norm);\n", " assert(h_pass);\n", " \n", " h_norm->SetDirectory(nullptr);\n", " h_pass->SetDirectory(nullptr);\n", "\n", " h_norm->Rebin(nrebin);\n", " h_pass->Rebin(nrebin);\n", "\n", " TH1 *h_ratio = GetBinominalRatio(h_pass, h_norm);\n", "\n", " // h_ratio->GetXaxis()->SetRangeUser(min_Et, max_Et);\n", " h_ratio->GetYaxis()->SetTitle(\"Tracking Purity\");\n", " h_ratio->GetYaxis()->SetRangeUser(-0, 1.1);\n", "\n", " TH1 *h_ratio_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH1 *h_pass =\n", " (TH1 *) qa_file_ref->GetObjectChecked(prefix + \"nGen_pTReco\", \"TH1\");\n", " TH1 *h_norm =\n", " (TH1 *) qa_file_ref->GetObjectChecked(prefix + \"nReco_pTReco\", \"TH1\");\n", " assert(h_norm);\n", " assert(h_pass);\n", " h_norm->SetDirectory(nullptr);\n", " h_pass->SetDirectory(nullptr);\n", " h_norm->Rebin(nrebin);\n", " h_pass->Rebin(nrebin);\n", " h_ratio_ref = GetBinominalRatio(h_pass, h_norm);\n", " }\n", "\n", " h_ratio->SetTitle(\"Tracking Purity (matched truth-reco pairs)\");\n", "\n", " DrawReference(h_ratio, h_ratio_ref, false);\n", " }\n", "\n", " {\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " TH1 *frame = p->DrawFrame(0, .9, 50, 1.1,\n", " \"Mean and sigma p_{Tmatched}/p_{Treco};Reco p_{T} [GeV/c]; #pm #sigma(p_{T,matched}/p_{T,reco})\");\n", " // gPad->SetLeftMargin(.2);\n", " gPad->SetTopMargin(-1);\n", " frame->GetYaxis()->SetTitleOffset(1.7);\n", " // TLine *l = new TLine(0, 1, 50, 1);\n", " // l->SetLineColor(kGray);\n", " // l->Draw();\n", " HorizontalLine(gPad, 1)->Draw();\n", "\n", " TH2 *h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco =\n", " (TH2 *) qa_file_new->GetObjectChecked(\n", " prefix + \"pTRecoTruthMatchedRatio_pTReco\", \"TH2\");\n", " assert(h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco);\n", "\n", " h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->SetDirectory(nullptr);\n", " h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->Rebin2D(16, 1);\n", "\n", " TGraphErrors *ge_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco =\n", " FitProfile(h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco);\n", " ge_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->Draw(\"pe\");\n", " ge_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->SetTitle(\n", " \"Mean and sigma p_{Tmatched}/p_{Treco}\");\n", "\n", " TGraphErrors *h_ratio_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2 *h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco =\n", " (TH2 *) qa_file_ref->GetObjectChecked(\n", " prefix + \"pTRecoTruthMatchedRatio_pTReco\", \"TH2\");\n", " assert(h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco);\n", "\n", " h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->SetDirectory(nullptr);\n", " h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->Rebin2D(16, 1);\n", "\n", " h_ratio_ref =\n", " FitProfile(h_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco);\n", " ge_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco->Draw(\"pe\");\n", " }\n", "\n", " DrawReference(ge_QAG4SimulationTracking_pTRecoTruthMatchedRatio_pTReco,\n", " h_ratio_ref, true);\n", " }\n", "\n", " c1->Draw();\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Tracker hit checks\n", "\n", "Hits per tracker and layer" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:13.306699Z", "iopub.status.busy": "2025-03-25T16:22:13.306490Z", "iopub.status.idle": "2025-03-25T16:22:13.413884Z", "shell.execute_reply": "2025-03-25T16:22:13.412820Z" } }, "outputs": [], "source": [ "%jsroot on" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:13.417922Z", "iopub.status.busy": "2025-03-25T16:22:13.417474Z", "iopub.status.idle": "2025-03-25T16:22:13.771773Z", "shell.execute_reply": "2025-03-25T16:22:13.770308Z" } }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "
\n", "
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "{\n", " const char *hist_name_prefix = \"QAG4SimulationTracking\";\n", " TString prefix = TString(\"h_\") + hist_name_prefix + TString(\"_\");\n", "\n", " // obtain normalization\n", " double Nevent_new = 1;\n", " double Nevent_ref = 1;\n", " \n", " \n", "\n", " if (qa_file_new)\n", " {\n", " TH1 *h_norm = (TH1 *) qa_file_new->GetObjectChecked(\n", " prefix + TString(\"Normalization\"), \"TH1\");\n", " assert(h_norm);\n", "\n", " Nevent_new = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " }\n", " if (qa_file_ref)\n", " {\n", " TH1 *h_norm = (TH1 *) qa_file_ref->GetObjectChecked(\n", " prefix + TString(\"Normalization\"), \"TH1\");\n", " assert(h_norm);\n", "\n", " Nevent_ref = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " }\n", "\n", " //MVTX, INTT, TPC\n", " vector detectors{\"MVTX\", \"INTT\", \"TPC\"};\n", " vector eff_ncluster_cuts{2, 2, 40};\n", " vector ncluster_spectrum_pt_cuts{2, 2, 2};\n", " vector h_pass_detectors(3, nullptr);\n", " static const int nrebin = 5;\n", "\n", " h_pass_detectors[0] = (TH2 *) qa_file_new->GetObjectChecked(\n", " prefix + \"nMVTX_nReco_pTGen\", \"TH1\") ;\n", " h_pass_detectors[1] = (TH2 *) qa_file_new->GetObjectChecked(\n", " prefix + \"nINTT_nReco_pTGen\", \"TH1\") ;\n", " h_pass_detectors[2] = (TH2 *) qa_file_new->GetObjectChecked(\n", " prefix + \"nTPC_nReco_pTGen\", \"TH1\") ;\n", "\n", " TH1 *h_norm = (TH1 *) qa_file_new->GetObjectChecked(\n", " prefix + \"nGen_pTGen\", \"TH1\") ;\n", " assert(h_norm);\n", " h_norm->SetDirectory(nullptr);\n", " h_norm->Rebin(nrebin);\n", "\n", " vector h_pass_detectors_ref(3, nullptr);\n", " TH1 *h_norm_ref = nullptr;\n", " if (qa_file_ref)\n", " {\n", " h_pass_detectors_ref[0] = (TH2 *) qa_file_ref->GetObjectChecked(\n", " prefix + \"nMVTX_nReco_pTGen\", \"TH1\") ;\n", " h_pass_detectors_ref[1] = (TH2 *) qa_file_ref->GetObjectChecked(\n", " prefix + \"nINTT_nReco_pTGen\", \"TH1\") ;\n", " h_pass_detectors_ref[2] = (TH2 *) qa_file_ref->GetObjectChecked(\n", " prefix + \"nTPC_nReco_pTGen\", \"TH1\") ;\n", "\n", " h_norm_ref = (TH1 *) qa_file_ref->GetObjectChecked(\n", " prefix + \"nGen_pTGen\", \"TH1\") ;\n", " h_norm_ref->SetDirectory(nullptr);\n", " h_norm_ref->Rebin(nrebin);\n", "\n", " }\n", "\n", " TCanvas *c1 = new TCanvas(TString(\"QA_Draw_Tracking_TruthMatching_NumOfClusters\") + TString(\"_\") + hist_name_prefix,\n", " TString(\"QA_Draw_Tracking_TruthMatching_NumOfClusters\") + TString(\"_\") + hist_name_prefix,\n", " 950, 600);\n", " c1->Divide(3, 2);\n", " TPad *p;\n", "\n", " for (int i = 0; i < 3; ++i)\n", " {\n", " TString detector = detectors[i];\n", " TH2 *h_pass_detector = h_pass_detectors[i];\n", " TH2 *h_pass_detector_ref = h_pass_detectors_ref[i];\n", " assert(h_pass_detector);\n", "\n", " {\n", " p = (TPad *) c1->cd(i + 1);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " const int bin_start = h_pass_detector->GetXaxis()->FindBin(ncluster_spectrum_pt_cuts[i]);\n", "\n", " TH1 *h_pass_detector_ncluster = h_pass_detector->ProjectionY(\n", " TString(h_pass_detector->GetName()) + \"_nCluster_new\",\n", " bin_start);\n", " TH1 *h_pass_detector_ncluster_ref = nullptr;\n", " if (h_pass_detector_ref)\n", " {\n", " h_pass_detector_ncluster_ref = h_pass_detector_ref->ProjectionY(\n", " TString(h_pass_detector_ref->GetName()) + \"_nCluster_ref\",\n", " bin_start);\n", " }\n", "\n", " h_pass_detector_ncluster->SetTitle(TString(hist_name_prefix) + \": \" + detector + Form(\" n_{Cluster} | p_{T} #geq %.1fGeV/c\", ncluster_spectrum_pt_cuts[i]));\n", " h_pass_detector_ncluster->SetYTitle(\"# of reconstructed track\");\n", " DrawReference(h_pass_detector_ncluster, h_pass_detector_ncluster_ref, false);\n", " }\n", "\n", " {\n", " p = (TPad *) c1->cd(i + 3 + 1);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetGridy();\n", "\n", " const int bin_start = h_pass_detector->GetYaxis()->FindBin(eff_ncluster_cuts[i]);\n", " TH1 *h_pass = h_pass_detector->ProjectionX(\n", " TString(h_pass_detector->GetName()) + \"_nReco_new\",\n", " bin_start);\n", "\n", " assert(h_pass);\n", " h_pass->SetDirectory(nullptr);\n", " h_pass->Rebin(nrebin);\n", "\n", " TH1 *h_ratio = GetBinominalRatio(h_pass, h_norm);\n", " h_ratio->GetYaxis()->SetTitle(\"Reco efficiency | \" + detector + Form(\" n_{Cluster} #geq %d\", eff_ncluster_cuts[i]));\n", " h_ratio->GetYaxis()->SetRangeUser(-0, 1.);\n", " //\n", " TH1 *h_ratio_ref = NULL;\n", " if (h_pass_detector_ref)\n", " {\n", " TH1 *h_pass = h_pass_detector_ref->ProjectionX(\n", " TString(h_pass_detector->GetName()) + \"_nReco_ref\",\n", " bin_start);\n", "\n", " assert(h_pass);\n", " h_pass->SetDirectory(nullptr);\n", " h_pass->Rebin(nrebin);\n", "\n", " h_ratio_ref = GetBinominalRatio(h_pass, h_norm_ref);\n", " }\n", " //\n", " h_ratio->SetTitle(\"Tracking efficiency | \" + detector + Form(\" n_{Cluster} #geq %d\", eff_ncluster_cuts[i]));\n", " DrawReference(h_ratio, h_ratio_ref, false);\n", " }\n", " }\n", "\n", " // SaveCanvas(c1, TString(qa_file_name_new) + TString(\"_\") + TString(c1->GetName()), true);\n", " c1->Draw();\n", "}" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:13.776640Z", "iopub.status.busy": "2025-03-25T16:22:13.776282Z", "iopub.status.idle": "2025-03-25T16:22:14.042304Z", "shell.execute_reply": "2025-03-25T16:22:14.040843Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Warning in : Deleting canvas with same name: QA_Draw_Tracking_TruthMatching_NumOfClusters_QAG4SimulationTracking\n" ] }, { "data": { "text/html": [ "\n", "\n", "
\n", "
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "{\n", " const char *hist_name_prefix = \"QAG4SimulationTracking\";\n", " TString prefix = TString(\"h_\") + hist_name_prefix + TString(\"_\");\n", "\n", " // obtain normalization\n", " double Nevent_new = 1;\n", " double Nevent_ref = 1;\n", " \n", " \n", "\n", " if (qa_file_new)\n", " {\n", " TH1 *h_norm = (TH1 *) qa_file_new->GetObjectChecked(\n", " prefix + TString(\"Normalization\"), \"TH1\");\n", " assert(h_norm);\n", "\n", " Nevent_new = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " }\n", " if (qa_file_ref)\n", " {\n", " TH1 *h_norm = (TH1 *) qa_file_ref->GetObjectChecked(\n", " prefix + TString(\"Normalization\"), \"TH1\");\n", " assert(h_norm);\n", "\n", " Nevent_ref = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " }\n", "\n", " //MVTX, INTT, TPC\n", " vector detectors{\"MVTX\", \"INTT\", \"TPC\"};\n", " vector eff_ncluster_cuts{2, 2, 40};\n", " vector ncluster_spectrum_pt_cuts{2, 2, 2};\n", " vector h_pass_detectors(3, nullptr);\n", " static const int nrebin = 5;\n", "\n", " h_pass_detectors[0] = (TH2 *) qa_file_new->GetObjectChecked(\n", " prefix + \"nMVTX_nReco_pTGen\", \"TH1\") ;\n", " h_pass_detectors[1] = (TH2 *) qa_file_new->GetObjectChecked(\n", " prefix + \"nINTT_nReco_pTGen\", \"TH1\") ;\n", " h_pass_detectors[2] = (TH2 *) qa_file_new->GetObjectChecked(\n", " prefix + \"nTPC_nReco_pTGen\", \"TH1\") ;\n", "\n", " TH1 *h_norm = (TH1 *) qa_file_new->GetObjectChecked(\n", " prefix + \"nGen_pTGen\", \"TH1\") ;\n", " assert(h_norm);\n", " h_norm->SetDirectory(nullptr);\n", " h_norm->Rebin(nrebin);\n", "\n", " vector h_pass_detectors_ref(3, nullptr);\n", " TH1 *h_norm_ref = nullptr;\n", " if (qa_file_ref)\n", " {\n", " h_pass_detectors_ref[0] = (TH2 *) qa_file_ref->GetObjectChecked(\n", " prefix + \"nMVTX_nReco_pTGen\", \"TH1\") ;\n", " h_pass_detectors_ref[1] = (TH2 *) qa_file_ref->GetObjectChecked(\n", " prefix + \"nINTT_nReco_pTGen\", \"TH1\") ;\n", " h_pass_detectors_ref[2] = (TH2 *) qa_file_ref->GetObjectChecked(\n", " prefix + \"nTPC_nReco_pTGen\", \"TH1\") ;\n", "\n", " h_norm_ref = (TH1 *) qa_file_ref->GetObjectChecked(\n", " prefix + \"nGen_pTGen\", \"TH1\") ;\n", " h_norm_ref->SetDirectory(nullptr);\n", " h_norm_ref->Rebin(nrebin);\n", "\n", " }\n", "\n", " TCanvas *c1 = new TCanvas(TString(\"QA_Draw_Tracking_TruthMatching_NumOfClusters\") + TString(\"_\") + hist_name_prefix,\n", " TString(\"QA_Draw_Tracking_TruthMatching_NumOfClusters\") + TString(\"_\") + hist_name_prefix,\n", " 950, 600);\n", " c1->Divide(3, 2);\n", " TPad *p;\n", "\n", " for (int i = 0; i < 3; ++i)\n", " {\n", " TString detector = detectors[i];\n", " TH2 *h_pass_detector = h_pass_detectors[i];\n", " TH2 *h_pass_detector_ref = h_pass_detectors_ref[i];\n", " assert(h_pass_detector);\n", "\n", " {\n", " p = (TPad *) c1->cd(i + 1);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " const int bin_start = h_pass_detector->GetXaxis()->FindBin(ncluster_spectrum_pt_cuts[i]);\n", "\n", " TH1 *h_pass_detector_ncluster = h_pass_detector->ProjectionY(\n", " TString(h_pass_detector->GetName()) + \"_nCluster_new\",\n", " bin_start);\n", " TH1 *h_pass_detector_ncluster_ref = nullptr;\n", " if (h_pass_detector_ref)\n", " {\n", " h_pass_detector_ncluster_ref = h_pass_detector_ref->ProjectionY(\n", " TString(h_pass_detector_ref->GetName()) + \"_nCluster_ref\",\n", " bin_start);\n", " }\n", "\n", " h_pass_detector_ncluster->SetTitle(TString(hist_name_prefix) + \": \" + detector + Form(\" n_{Cluster} | p_{T} #geq %.1fGeV/c\", ncluster_spectrum_pt_cuts[i]));\n", " h_pass_detector_ncluster->SetYTitle(\"# of reconstructed track\");\n", " DrawReference(h_pass_detector_ncluster, h_pass_detector_ncluster_ref, false);\n", " }\n", "\n", " {\n", " p = (TPad *) c1->cd(i + 3 + 1);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetGridy();\n", "\n", " const int bin_start = h_pass_detector->GetYaxis()->FindBin(eff_ncluster_cuts[i]);\n", " TH1 *h_pass = h_pass_detector->ProjectionX(\n", " TString(h_pass_detector->GetName()) + \"_nReco_new\",\n", " bin_start);\n", "\n", " assert(h_pass);\n", " h_pass->SetDirectory(nullptr);\n", " h_pass->Rebin(nrebin);\n", "\n", " TH1 *h_ratio = GetBinominalRatio(h_pass, h_norm);\n", " h_ratio->GetYaxis()->SetTitle(\"Reco efficiency | \" + detector + Form(\" n_{Cluster} #geq %d\", eff_ncluster_cuts[i]));\n", " h_ratio->GetYaxis()->SetRangeUser(-0, 1.);\n", " //\n", " TH1 *h_ratio_ref = NULL;\n", " if (h_pass_detector_ref)\n", " {\n", " TH1 *h_pass = h_pass_detector_ref->ProjectionX(\n", " TString(h_pass_detector->GetName()) + \"_nReco_ref\",\n", " bin_start);\n", "\n", " assert(h_pass);\n", " h_pass->SetDirectory(nullptr);\n", " h_pass->Rebin(nrebin);\n", "\n", " h_ratio_ref = GetBinominalRatio(h_pass, h_norm_ref);\n", " }\n", " //\n", " h_ratio->SetTitle(\"Tracking efficiency | \" + detector + Form(\" n_{Cluster} #geq %d\", eff_ncluster_cuts[i]));\n", " DrawReference(h_ratio, h_ratio_ref, false);\n", " }\n", " }\n", "\n", " // SaveCanvas(c1, TString(qa_file_name_new) + TString(\"_\") + TString(c1->GetName()), true);\n", " c1->Draw();\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Hits per layer" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:14.047323Z", "iopub.status.busy": "2025-03-25T16:22:14.047100Z", "iopub.status.idle": "2025-03-25T16:22:14.170450Z", "shell.execute_reply": "2025-03-25T16:22:14.169240Z" } }, "outputs": [], "source": [ "%%cpp -d\n", "\n", "\n", "namespace\n", "{\n", " // Normalization\n", " double Nevent_new = 1;\n", " double Nevent_ref = 1;\n", "\n", " void GetNormalization(TFile *qa_file_new, TFile *qa_file_ref, const TString &prefix, const TString &tag)\n", " {\n", " if (qa_file_new)\n", " {\n", " TH1 *h_norm = (TH1 *) qa_file_new->GetObjectChecked(prefix + TString(\"Normalization\"), \"TH1\");\n", " assert(h_norm);\n", " Nevent_new = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(tag));\n", " }\n", "\n", " if (qa_file_ref)\n", " {\n", " TH1 *h_norm = (TH1 *) qa_file_ref->GetObjectChecked(prefix + TString(\"Normalization\"), \"TH1\");\n", " assert(h_norm);\n", " Nevent_ref = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(tag));\n", " }\n", " }\n", "\n", " void Draw(TFile *qa_file_new, TFile *qa_file_ref, const TString &prefix, const TString &tag)\n", " {\n", " auto h_new = static_cast(qa_file_new->GetObjectChecked(prefix + tag, \"TH1\"));\n", " assert(h_new);\n", " //h_new->Sumw2();\n", " h_new->Scale(1. / Nevent_new);\n", "\n", " TH1 *h_ref = nullptr;\n", " if (qa_file_ref)\n", " {\n", " h_ref = static_cast(qa_file_ref->GetObjectChecked(prefix + tag, \"TH1\"));\n", " assert(h_ref);\n", " //h_ref->Sumw2();\n", " h_ref->Scale(1.0 / Nevent_ref);\n", " }\n", "\n", " DrawReference(h_new, h_ref);\n", " HorizontalLine(gPad, 1)->Draw();\n", " }\n", "\n", "} // namespace" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:14.174305Z", "iopub.status.busy": "2025-03-25T16:22:14.173976Z", "iopub.status.idle": "2025-03-25T16:22:14.331337Z", "shell.execute_reply": "2025-03-25T16:22:14.330309Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "KSTestSummary::PushKSTest - Warning - received pValue = 0. Reset to an arbitary small non-zero value (e^(-15))\n" ] }, { "data": { "text/html": [ "\n", "\n", "
\n", "
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "{\n", " const char *hist_name_prefix = \"QAG4SimulationTracking\";\n", " TString prefix = TString(\"h_\") + hist_name_prefix + TString(\"_\");\n", "\n", " auto c1 = new TCanvas(TString(\"QA_Draw_Tracking_nClus_Layer\") + TString(\"_\") + hist_name_prefix,\n", " TString(\"QA_Draw_Tracking_nClus_Layer\") + TString(\"_\") + hist_name_prefix,\n", " 950, 600);\n", "\n", " c1->Divide(2, 1);\n", " c1->cd(1);\n", " GetNormalization(qa_file_new, qa_file_ref, prefix, \"Truth Track\");\n", " Draw(qa_file_new, qa_file_ref, prefix, \"nClus_layerGen\");\n", "\n", " c1->cd(2);\n", " GetNormalization(qa_file_new, qa_file_ref, prefix, \"Reco Track\");\n", " Draw(qa_file_new, qa_file_ref, prefix, \"nClus_layer\");\n", "\n", " // SaveCanvas(c1, TString(qa_file_name_new) + TString(\"_\") + TString(c1->GetName()), true);\n", " c1->Draw();\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Upsilon reconstruction\n", "\n", "One $\\Upsilon(1S) \\rightarrow e^+ e^-$ is embedded. Here is its reco results" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:14.334508Z", "iopub.status.busy": "2025-03-25T16:22:14.334179Z", "iopub.status.idle": "2025-03-25T16:22:14.460578Z", "shell.execute_reply": "2025-03-25T16:22:14.459609Z" } }, "outputs": [], "source": [ "%%cpp -d\n", "\n", "// square\n", "inline double square( const double& x ) { return x*x; }\n", "\n", "// christal ball function for momentum resolution fit\n", "Double_t CBcalc(Double_t *xx, Double_t *par)\n", "{\n", " // Crystal Ball fit to one state\n", " double f;\n", " const double x = xx[0];\n", "\n", " // The four parameters (alpha, n, x_mean, sigma) plus normalization (N) are:\n", " \n", " const double alpha = par[0];\n", " const double n = par[1];\n", " const double x_mean = par[2];\n", " const double sigma = par[3];\n", " const double N = par[4];\n", "\n", " // dimensionless variable\n", " const double t = (x-x_mean)/sigma;\n", "\n", " // The Crystal Ball function is:\n", " \n", " if( t > -alpha)\n", " {\n", " return N * exp( -square(t)/2 );\n", " }\n", " else\n", " {\n", " const double A = pow( (n/TMath::Abs(alpha)),n) * exp(-square(alpha)/2.0);\n", " const double B = n/TMath::Abs(alpha) - TMath::Abs(alpha);\n", " return N * A * pow(B - t, -n);\n", " }\n", "\n", "}\n", "\n", "// christal ball function for Upsilon fits\n", "Double_t CBcalc2(Double_t *xx, Double_t *par)\n", "{\n", " // Crystal Ball fit to one state\n", " const double x = xx[0];\n", "\n", " /* The parameters are: \n", " * N the normalization\n", " * x_mean, sigma\n", " * alpha_left, n_left\n", " * alpha_right, n_right\n", " */\n", " const double N = par[0];\n", " const double x_mean = par[1];\n", " const double sigma = par[2];\n", " const double t = (x-x_mean)/sigma; \n", "\n", " // left tail\n", " const double alpha_left = std::abs(par[3]);\n", " const double n_left = par[4];\n", "\n", " // right tail\n", " const double alpha_right = std::abs(par[5]);\n", " const double n_right = par[6];\n", " \n", " // The Crystal Ball function is: \n", " if( t < -alpha_left )\n", " { \n", " const double A = pow( (n_left/TMath::Abs(alpha_left)),n_left) * exp(-square(alpha_left)/2.0);\n", " const double B = n_left/std::abs(alpha_left) - std::abs(alpha_left);\n", " return N * A * pow(B - t, -n_left);\n", " } else if( t > alpha_right ) {\n", " const double A = pow( (n_right/TMath::Abs(alpha_right)),n_right) * exp(-square(alpha_right)/2.0);\n", " const double B = n_right/std::abs(alpha_right) - std::abs(alpha_right);\n", " return N * A * pow(B + t, -n_right); \n", " } else {\n", " return N * exp( -square(t)/2);\n", " }\n", "}\n" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:14.464566Z", "iopub.status.busy": "2025-03-25T16:22:14.464332Z", "iopub.status.idle": "2025-03-25T16:22:14.785946Z", "shell.execute_reply": "2025-03-25T16:22:14.784797Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "****************************************\n", "Minimizer is Minuit2 / Migrad\n", "Chi2 = 252.723\n", "NDf = 258\n", "Edm = 2.15351e-06\n", "NCalls = 288\n", "alpha = 1.35923 +/- 0.10647 \n", "n = 0.704631 +/- 0.0762302 \n", "m = 0.993478 +/- 0.00137097 \n", "sigma = 0.0227885 +/- 0.00165465 \n", "N = 68.974 +/- 4.01965 \n", "****************************************\n", "Minimizer is Minuit2 / Migrad\n", "Chi2 = 261.726\n", "NDf = 262\n", "Edm = 1.42453e-07\n", "NCalls = 326\n", "alpha = 1.23928 +/- 0.0596344 \n", "n = 0.884641 +/- 0.0528633 \n", "m = 0.99592 +/- 0.000706316 \n", "sigma = 0.0204218 +/- 0.000789757 \n", "N = 101.387 +/- 4.18346 \n", "****************************************\n", "Minimizer is Minuit2 / Migrad\n", "Chi2 = 130.802\n", "NDf = 195\n", "Edm = 1.37271e-05\n", "NCalls = 801\n", "N = 11.2474 +/- 2.09969 \n", "m = 9.50294 +/- 0.0181701 \n", "#sigma = 0.046622 +/- 0.0132821 \n", "#alpha_{left} = 0.120016 +/- 0.48547 \t (limited)\n", "n_{left} = 1.05 +/- 0.0168182 \t (limited)\n", "#alpha_{right} = 0.853692 +/- 0.178662 \t (limited)\n", "#sigma_{right} = 1.05 +/- 0.155876 \t (limited)\n", "****************************************\n", "Minimizer is Minuit2 / Migrad\n", "Chi2 = 119.46\n", "NDf = 192\n", "Edm = 2.03427e-06\n", "NCalls = 447\n", "N = 24.0374 +/- 2.85435 \n", "m = 9.46004 +/- 0.0228778 \n", "#sigma = 0.10052 +/- 0.0326309 \n", "#alpha_{left} = 0.410059 +/- 0.105766 \t (limited)\n", "n_{left} = 1.05 +/- 0.0162644 \t (limited)\n", "#alpha_{right} = 1.20003 +/- 0.21101 \t (limited)\n", "#sigma_{right} = 1.05 +/- 0.204233 \t (limited)\n" ] }, { "data": { "text/html": [ "\n", "\n", "
\n", "
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "\n", "{\n", " const char *hist_name_prefix = \"QAG4SimulationUpsilon\";\n", " TString prefix = TString(\"h_\") + hist_name_prefix + TString(\"_\");\n", "\n", " // obtain normalization\n", " double Nevent_new = 1;\n", " double Nevent_ref = 1;\n", "\n", " if ( qa_file_new->GetObjectChecked(\n", " prefix + TString(\"pTRecoGenRatio_pTGen\"), \"TH2\")\n", " == nullptr )\n", " {\n", " cout <<\"QAG4SimulationUpsilon is not enabled. Skip....\"<Divide(2, 1);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " {\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " TH2 *h_new = (TH2 *) qa_file_new->GetObjectChecked(\n", " prefix + TString(\"pTRecoGenRatio_pTGen\"), \"TH2\");\n", " assert(h_new);\n", "\n", " // h_new->Rebin(1, 2);\n", " //h_new->Sumw2();\n", " // h_new->Scale(1. / Nevent_new);\n", "\n", " TH2 *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH2 *) qa_file_ref->GetObjectChecked(\n", " prefix + TString(\"pTRecoGenRatio_pTGen\"), \"TH2\");\n", " assert(h_ref);\n", "\n", " // h_ref->Rebin(1, 2);\n", " //h_ref->Sumw2();\n", " h_ref->Scale(Nevent_new / Nevent_ref);\n", " }\n", "\n", " TH1 *h_proj_new = h_new->ProjectionY(\n", " TString::Format(\n", " \"%s_New_ProjX\",\n", " h_new->GetName()));\n", "\n", " h_proj_new->GetXaxis()->SetRangeUser(0, 1.3);\n", " h_proj_new->SetTitle(TString(hist_name_prefix) + TString::Format(\n", " \": Electron lineshape\"));\n", " h_proj_new->GetXaxis()->SetTitle(TString::Format(\n", " \"Reco p_{T}/Truth p_{T}\"));\n", "\n", " TF1 *f_eLineshape = new TF1(\"f_eLineshape\", CBcalc, 7, 11, 5);\n", " f_eLineshape->SetParameter(0, 1.0);\n", " f_eLineshape->SetParameter(1, 1.0);\n", " f_eLineshape->SetParameter(2, 0.95);\n", " f_eLineshape->SetParameter(3, 0.08);\n", " f_eLineshape->SetParameter(4, 20.0);\n", "\n", " f_eLineshape->SetParNames(\"alpha\",\"n\",\"m\",\"sigma\",\"N\");\n", " f_eLineshape->SetLineColor(kRed);\n", " f_eLineshape->SetLineWidth(3);\n", " f_eLineshape->SetLineStyle(kSolid);\n", " f_eLineshape->SetNpx(1000);\n", "\n", " h_proj_new->Fit(f_eLineshape);\n", "\n", " TH1 *h_proj_ref = nullptr;\n", " if (h_ref)\n", " {\n", " h_proj_ref =\n", " h_ref->ProjectionY(\n", " TString::Format(\n", " \"%s_Ref_ProjX\",\n", " h_new->GetName()));\n", " }\n", " TF1 *f_eLineshape_ref = new TF1(\"f_eLineshape_ref\", CBcalc, 7, 11, 5);\n", " f_eLineshape_ref->SetParameter(0, 1.0);\n", " f_eLineshape_ref->SetParameter(1, 1.0);\n", " f_eLineshape_ref->SetParameter(2, 0.95);\n", " f_eLineshape_ref->SetParameter(3, 0.08);\n", " f_eLineshape_ref->SetParameter(4, 20.0);\n", "\n", " f_eLineshape_ref->SetParNames(\"alpha\",\"n\",\"m\",\"sigma\",\"N\");\n", " f_eLineshape_ref->SetLineColor(kRed);\n", " f_eLineshape_ref->SetLineWidth(3);\n", " f_eLineshape_ref->SetLineStyle(kSolid);\n", "\n", " h_proj_ref->Fit(f_eLineshape_ref);\n", "\n", "\n", " DrawReference(h_proj_new, h_proj_ref);\n", " f_eLineshape->Draw(\"same\");\n", "\n", " char resstr_1[500];\n", " sprintf(resstr_1,\"#sigma_{dp/p} = %.2f #pm %.2f %%\", f_eLineshape->GetParameter(3)*100, f_eLineshape->GetParError(3)*100);\n", " TLatex *res_1 = new TLatex(0.2,0.75,resstr_1);\n", " res_1->SetNDC();\n", " res_1->SetTextSize(0.05);\n", " res_1->SetTextAlign(13);\n", " res_1->Draw();\n", "\n", " char resstr_2[500];\n", " sprintf(resstr_2,\"#sigma_{dp/p,ref} = %.2f #pm %.2f %%\", f_eLineshape_ref->GetParameter(3)*100, f_eLineshape_ref->GetParError(3)*100);\n", " TLatex *res_2 = new TLatex(0.2,0.7,resstr_2);\n", " res_2->SetNDC();\n", " res_2->SetTextSize(0.05);\n", " res_2->SetTextAlign(13);\n", " res_2->Draw();\n", " }\n", "\n", " {\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogy();\n", "\n", " TH1 *h_new = (TH1 *) qa_file_new->GetObjectChecked(\n", " prefix + TString(\"nReco_Pair_InvMassReco\"), \"TH1\");\n", " assert(h_new);\n", "\n", " // h_new->Rebin(2);\n", " // h_new->Sumw2();\n", " // h_new->Scale(1. / Nevent_new);\n", "\n", " TF1 *f1S = new TF1(\"f1S\", CBcalc2, 7, 11, 7);\n", " f1S->SetParameter(0, 50.0);\n", " f1S->SetParameter(1, 9.46);\n", " f1S->SetParameter(2, 0.08);\n", " f1S->SetParameter(3, 1.0);\n", " f1S->SetParameter(4, 3.0);\n", " f1S->SetParameter(5, 1.0);\n", " f1S->SetParLimits(3, 0.120, 10);\n", " f1S->SetParLimits(4, 1.05, 10);\n", " f1S->SetParameter(6, 3.0);\n", " f1S->SetParLimits(5, 0.120, 10);\n", " f1S->SetParLimits(6, 1.05, 10);\n", " \n", " f1S->SetParNames(\"N\", \"m\", \"#sigma\", \"#alpha_{left}\",\"n_{left}\",\"#alpha_{right}\",\"#sigma_{right}\");\n", " f1S->SetLineColor(kRed);\n", " f1S->SetLineWidth(3);\n", " f1S->SetLineStyle(kSolid);\n", " f1S->SetNpx(1000);\n", "\n", " h_new->Fit(f1S);\n", "\n", " TH1 *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1 *) qa_file_ref->GetObjectChecked(\n", " prefix + TString(\"nReco_Pair_InvMassReco\"), \"TH1\");\n", " assert(h_ref);\n", "\n", " // h_ref->Rebin(2);\n", " // h_ref->Sumw2();\n", " // h_ref->Scale(Nevent_new / Nevent_ref);\n", " }\n", "\n", " h_new->SetTitle(TString(hist_name_prefix) + TString::Format(\n", " \": #Upsilon #rightarrow e^{+}e^{-} lineshape\"));\n", " h_new->GetXaxis()->SetRangeUser(7, 10);\n", "\n", " TF1 *f1S_ref = new TF1(\"f1S_ref\", CBcalc2, 7, 11, 7);\n", " f1S_ref->SetParameter(0, 50.0);\n", " f1S_ref->SetParameter(1, 9.46);\n", " f1S_ref->SetParameter(2, 0.08);\n", " f1S_ref->SetParameter(3, 1.0);\n", " f1S_ref->SetParameter(4, 3.0);\n", " f1S_ref->SetParameter(5, 1.0);\n", " f1S_ref->SetParLimits(3, 0.120, 10);\n", " f1S_ref->SetParLimits(4, 1.05, 10);\n", " f1S_ref->SetParameter(6, 3.0);\n", " f1S_ref->SetParLimits(5, 0.120, 10);\n", " f1S_ref->SetParLimits(6, 1.05, 10);\n", " \n", " f1S_ref->SetParNames(\"N\", \"m\", \"#sigma\", \"#alpha_{left}\",\"n_{left}\",\"#alpha_{right}\",\"#sigma_{right}\");\n", " f1S_ref->SetLineColor(kRed);\n", " f1S_ref->SetLineWidth(3);\n", " f1S_ref->SetLineStyle(kSolid);\n", "\n", " h_ref->Fit(f1S_ref);\n", "\n", " DrawReference(h_new, h_ref, false);\n", " f1S->Draw(\"same\");\n", "\n", " // cout << \"f1S pars \" << f1S->GetParameter(3) << \" \" << f1S->GetParError(3) << endl;\n", "\n", " char resstr_3[500];\n", " sprintf(resstr_3,\"#sigma_{1S} = %.1f #pm %.1f MeV\", f1S->GetParameter(2)*1000, f1S->GetParError(2)*1000);\n", " TLatex *res_3 = new TLatex(0.2,0.75,resstr_3);\n", " res_3->SetNDC();\n", " res_3->SetTextSize(0.05);\n", " res_3->SetTextAlign(13);\n", " res_3->Draw();\n", "\n", " char resstr_4[500];\n", " sprintf(resstr_4,\"#sigma_{1S,ref} = %.1f #pm %.1f MeV\", f1S_ref->GetParameter(2)*1000, f1S_ref->GetParError(2)*1000);\n", " TLatex *res_4 = new TLatex(0.2,0.7,resstr_4);\n", " res_4->SetNDC();\n", " res_4->SetTextSize(0.05);\n", " res_4->SetTextAlign(13);\n", " res_4->Draw();\n", " \n", " ofstream fcsv;\n", " fcsv.open (\"Upsilon_mean.csv\");\n", " fcsv<<\"Upsilon mean (GeV)\"<GetParameter(1)<GetParameter(2)<GetParameter(0)<GetName()), true);\n", "\n", " c1 -> Draw();\n", " }// if checks\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Summary statistics" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:14.789260Z", "iopub.status.busy": "2025-03-25T16:22:14.789005Z", "iopub.status.idle": "2025-03-25T16:22:14.937449Z", "shell.execute_reply": "2025-03-25T16:22:14.936309Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "This notebook contains 25 KSTets: combined Chi2/nDoF = 387.529 / 50, and combined __p-Value = 1.01895e-53__\n" ] } ], "source": [ "%%cpp\n", "\n", "KSTestSummary::getInstance()->make_summary_txt(\"QA-tracking.txt\");" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T16:22:14.940252Z", "iopub.status.busy": "2025-03-25T16:22:14.939933Z", "iopub.status.idle": "2025-03-25T16:22:15.066824Z", "shell.execute_reply": "2025-03-25T16:22:15.066045Z" } }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "
\n", "
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "\n", "KSTestSummary::getInstance()->make_summary_TCanvas() -> Draw();" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python (sPHENIX)", "language": "python", "name": "sphenix-env" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.0" } }, "nbformat": 4, "nbformat_minor": 4 }