{ "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-25T17:00:32.633699Z", "iopub.status.busy": "2025-03-25T17:00:32.633052Z", "iopub.status.idle": "2025-03-25T17:00:32.639990Z", "shell.execute_reply": "2025-03-25T17:00:32.639054Z" } }, "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-25T17:00:32.644254Z", "iopub.status.busy": "2025-03-25T17:00:32.643718Z", "iopub.status.idle": "2025-03-25T17:00:32.658429Z", "shell.execute_reply": "2025-03-25T17:00:32.657613Z" } }, "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-25T17:00:32.730480Z", "iopub.status.busy": "2025-03-25T17:00:32.729728Z", "iopub.status.idle": "2025-03-25T17:00:32.739846Z", "shell.execute_reply": "2025-03-25T17:00:32.738904Z" } }, "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-low-occupancy)\n", "\n", "## Tracking QA at low occupancy\n", "\n", "Low occupancy tracking QA concists full tracker + reconstruction of events with 20 $\\pi^+$, 20 $\\pi^-$ and one $\\Upsilon(1S) \\rightarrow e^+ e^-$. Please note the calorimeters are disabled to improve execution speed, which also removed some of the correlated albedo background for the tracker. \n", "\n", "The source code of the macro can be found at https://github.com/sPHENIX-Collaboration/macros/tree/QA-tracking-low-occupancy or [comparing it to the master branch](https://github.com/sPHENIX-Collaboration/macros/compare/QA-tracking-low-occupancy?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-25T17:00:32.743319Z", "iopub.status.busy": "2025-03-25T17:00:32.742740Z", "iopub.status.idle": "2025-03-25T17:00:38.855754Z", "shell.execute_reply": "2025-03-25T17:00:38.854834Z" }, "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-25T17:00:38.860396Z", "iopub.status.busy": "2025-03-25T17:00:38.860095Z", "iopub.status.idle": "2025-03-25T17:00:38.986477Z", "shell.execute_reply": "2025-03-25T17:00:38.985442Z" } }, "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-25T17:00:38.991311Z", "iopub.status.busy": "2025-03-25T17:00:38.990780Z", "iopub.status.idle": "2025-03-25T17:00:39.116804Z", "shell.execute_reply": "2025-03-25T17:00:39.115358Z" } }, "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-low-occupancy-qa/7018/" ], "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-low-occupancy-qa/7018/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-25T17:00:39.122015Z", "iopub.status.busy": "2025-03-25T17:00:39.121390Z", "iopub.status.idle": "2025-03-25T17:00:39.648407Z", "shell.execute_reply": "2025-03-25T17:00:39.647318Z" }, "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-25T17:00:39.653014Z", "iopub.status.busy": "2025-03-25T17:00:39.652517Z", "iopub.status.idle": "2025-03-25T17:00:40.414921Z", "shell.execute_reply": "2025-03-25T17:00:40.414286Z" } }, "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-25T17:00:40.418265Z", "iopub.status.busy": "2025-03-25T17:00:40.417913Z", "iopub.status.idle": "2025-03-25T17:00:40.563957Z", "shell.execute_reply": "2025-03-25T17:00:40.562655Z" } }, "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-25T17:00:40.568747Z", "iopub.status.busy": "2025-03-25T17:00:40.568216Z", "iopub.status.idle": "2025-03-25T17:00:40.679136Z", "shell.execute_reply": "2025-03-25T17:00:40.677692Z" } }, "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-25T17:00:40.684191Z", "iopub.status.busy": "2025-03-25T17:00:40.683573Z", "iopub.status.idle": "2025-03-25T17:00:40.874137Z", "shell.execute_reply": "2025-03-25T17:00:40.873269Z" } }, "outputs": [ { "data": { "text/markdown": [ "Opening QA file at `G4sPHENIX_test-tracking_Event400_Sum28_qa.root`" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/markdown": [ "Opening QA reference file at `reference/G4sPHENIX_test-tracking_Event400_Sum28_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-25T17:00:40.878954Z", "iopub.status.busy": "2025-03-25T17:00:40.878333Z", "iopub.status.idle": "2025-03-25T17:00:41.007368Z", "shell.execute_reply": "2025-03-25T17:00:41.006493Z" }, "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-25T17:00:43.353216Z", "iopub.status.busy": "2025-03-25T17:00:43.352776Z", "iopub.status.idle": "2025-03-25T17:00:43.467585Z", "shell.execute_reply": "2025-03-25T17:00:43.466415Z" } }, "outputs": [], "source": [ "%jsroot off" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T17:00:43.472843Z", "iopub.status.busy": "2025-03-25T17:00:43.472210Z", "iopub.status.idle": "2025-03-25T17:00:44.026838Z", "shell.execute_reply": "2025-03-25T17:00:44.026042Z" } }, "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": { "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-25T17:00:44.030855Z", "iopub.status.busy": "2025-03-25T17:00:44.030448Z", "iopub.status.idle": "2025-03-25T17:00:44.138975Z", "shell.execute_reply": "2025-03-25T17:00:44.137900Z" } }, "outputs": [], "source": [ "%jsroot on" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T17:00:44.143264Z", "iopub.status.busy": "2025-03-25T17:00:44.142665Z", "iopub.status.idle": "2025-03-25T17:00:44.575837Z", "shell.execute_reply": "2025-03-25T17:00:44.575013Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "KSTestSummary::PushKSTest - Warning - received pValue = 0. Reset to an arbitary small non-zero value (e^(-15))\n", "KSTestSummary::PushKSTest - Warning - received pValue = 0. Reset to an arbitary small non-zero value (e^(-15))\n", "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", "{\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, 20},\n", " {20, 30},\n", " {30, 40},\n", " {40, 45},\n", " {45, 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-25T17:00:44.584517Z", "iopub.status.busy": "2025-03-25T17:00:44.584145Z", "iopub.status.idle": "2025-03-25T17:00:44.691421Z", "shell.execute_reply": "2025-03-25T17:00:44.690280Z" } }, "outputs": [], "source": [ "%jsroot off" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T17:00:44.696887Z", "iopub.status.busy": "2025-03-25T17:00:44.695962Z", "iopub.status.idle": "2025-03-25T17:00:45.127581Z", "shell.execute_reply": "2025-03-25T17:00:45.126821Z" } }, "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-25T17:00:45.132102Z", "iopub.status.busy": "2025-03-25T17:00:45.131686Z", "iopub.status.idle": "2025-03-25T17:00:45.540289Z", "shell.execute_reply": "2025-03-25T17:00:45.539644Z" } }, "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-25T17:00:45.544407Z", "iopub.status.busy": "2025-03-25T17:00:45.544042Z", "iopub.status.idle": "2025-03-25T17:00:45.651516Z", "shell.execute_reply": "2025-03-25T17:00:45.650298Z" } }, "outputs": [], "source": [ "%jsroot on" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "execution": { "iopub.execute_input": "2025-03-25T17:00:45.656432Z", "iopub.status.busy": "2025-03-25T17:00:45.655819Z", "iopub.status.idle": "2025-03-25T17:00:46.054034Z", "shell.execute_reply": "2025-03-25T17:00:46.053071Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "KSTestSummary::PushKSTest - Warning - received pValue = 0. Reset to an arbitary small non-zero value (e^(-15))\n", "KSTestSummary::PushKSTest - Warning - received pValue = 0. Reset to an arbitary small non-zero value (e^(-15))\n", "KSTestSummary::PushKSTest - Warning - received pValue = 0. Reset to an arbitary small non-zero value (e^(-15))\n", "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", " // 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-25T17:00:46.060926Z", "iopub.status.busy": "2025-03-25T17:00:46.060415Z", "iopub.status.idle": "2025-03-25T17:00:46.353717Z", "shell.execute_reply": "2025-03-25T17:00:46.353036Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "KSTestSummary::PushKSTest - Warning - received pValue = 0. Reset to an arbitary small non-zero value (e^(-15))\n", "KSTestSummary::PushKSTest - Warning - received pValue = 0. Reset to an arbitary small non-zero value (e^(-15))\n", "KSTestSummary::PushKSTest - Warning - received pValue = 0. Reset to an arbitary small non-zero value (e^(-15))\n", "KSTestSummary::PushKSTest - Warning - received pValue = 0. Reset to an arbitary small non-zero value (e^(-15))\n" ] }, { "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-25T17:00:46.360642Z", "iopub.status.busy": "2025-03-25T17:00:46.360248Z", "iopub.status.idle": "2025-03-25T17:00:46.482635Z", "shell.execute_reply": "2025-03-25T17:00:46.481541Z" } }, "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-25T17:00:46.487611Z", "iopub.status.busy": "2025-03-25T17:00:46.487044Z", "iopub.status.idle": "2025-03-25T17:00:46.667001Z", "shell.execute_reply": "2025-03-25T17:00:46.666156Z" } }, "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-25T17:00:46.672446Z", "iopub.status.busy": "2025-03-25T17:00:46.671953Z", "iopub.status.idle": "2025-03-25T17:00:46.801236Z", "shell.execute_reply": "2025-03-25T17:00:46.800295Z" } }, "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-25T17:00:46.806538Z", "iopub.status.busy": "2025-03-25T17:00:46.805962Z", "iopub.status.idle": "2025-03-25T17:00:47.218277Z", "shell.execute_reply": "2025-03-25T17:00:47.217680Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "****************************************\n", " Invalid FitResult (status = 3 )\n", "****************************************\n", "Minimizer is Minuit2 / Migrad\n", "Chi2 = 1557.86\n", "NDf = 302\n", "Edm = 127439\n", "NCalls = 942\n", "alpha = -0.643375 +/- 1.00003 \n", "n = 1.28936 +/- 1.00021 \n", "m = 0.997789 +/- 1 \n", "sigma = 0.0189798 +/- 1 \n", "N = 388.082 +/- 6.83573 \n", "****************************************\n", "Minimizer is Minuit2 / Migrad\n", "Chi2 = 718.691\n", "NDf = 367\n", "Edm = 3.38725e-07\n", "NCalls = 597\n", "alpha = 1.21811 +/- 0.0232098 \n", "n = 0.953047 +/- 0.0185185 \n", "m = 0.997167 +/- 0.000238494 \n", "sigma = 0.0163169 +/- 0.000223389 \n", "N = 863.786 +/- 12.7091 \n", "****************************************\n", "Minimizer is Minuit2 / Migrad\n", "Chi2 = 413.563\n", "NDf = 351\n", "Edm = 5.95627e-06\n", "NCalls = 558\n", "N = 117.28 +/- 5.38846 \n", "m = 9.43477 +/- 0.00706503 \n", "#sigma = 0.107821 +/- 0.00784131 \n", "#alpha_{left} = 0.520053 +/- 0.0301615 \t (limited)\n", "n_{left} = 1.05 +/- 0.00415039 \t (limited)\n", "#alpha_{right} = 1.99312 +/- 0.0862669 \t (limited)\n", "#sigma_{right} = 1.05 +/- 0.0158688 \t (limited)\n", "****************************************\n", "Minimizer is Minuit2 / Migrad\n", "Chi2 = 478.721\n", "NDf = 331\n", "Edm = 2.2803e-07\n", "NCalls = 496\n", "N = 204.728 +/- 1.87329 \n", "m = 9.42249 +/- 0.00594171 \n", "#sigma = 0.126503 +/- 0.00412685 \n", "#alpha_{left} = 0.659405 +/- 0.0384828 \t (limited)\n", "n_{left} = 1.15196 +/- 0.0372615 \t (limited)\n", "#alpha_{right} = 5.47513 +/- 7.47196 \t (limited)\n", "#sigma_{right} = 9.9397 +/- 7.86707 \t (limited)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Warning in : Abnormal termination of minimization.\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-25T17:00:47.225421Z", "iopub.status.busy": "2025-03-25T17:00:47.225058Z", "iopub.status.idle": "2025-03-25T17:00:47.372297Z", "shell.execute_reply": "2025-03-25T17:00:47.371417Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "This notebook contains 28 KSTets: combined Chi2/nDoF = 2257.25 / 56, and combined __p-Value = 0__\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-25T17:00:47.376542Z", "iopub.status.busy": "2025-03-25T17:00:47.376008Z", "iopub.status.idle": "2025-03-25T17:00:47.516965Z", "shell.execute_reply": "2025-03-25T17:00:47.515910Z" } }, "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 }