{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Introduction\n", "\n", "QA plots for the calorimeter response to single particle inputs" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:15.129874Z", "iopub.status.busy": "2025-03-24T22:25:15.129066Z", "iopub.status.idle": "2025-03-24T22:25:15.134835Z", "shell.execute_reply": "2025-03-24T22:25:15.134091Z" } }, "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-24T22:25:15.138672Z", "iopub.status.busy": "2025-03-24T22:25:15.138178Z", "iopub.status.idle": "2025-03-24T22:25:15.152159Z", "shell.execute_reply": "2025-03-24T22:25:15.151191Z" } }, "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-24T22:25:15.197781Z", "iopub.status.busy": "2025-03-24T22:25:15.196521Z", "iopub.status.idle": "2025-03-24T22:25:25.343588Z", "shell.execute_reply": "2025-03-24T22:25:25.341885Z" } }, "outputs": [ { "data": { "text/markdown": [ "pyROOT env check:" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "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": [ "# initialization\n", "\n", "display(Markdown('pyROOT env check:'))\n", "\n", "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": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:25.349248Z", "iopub.status.busy": "2025-03-24T22:25:25.348964Z", "iopub.status.idle": "2025-03-24T22:25:25.488148Z", "shell.execute_reply": "2025-03-24T22:25:25.486753Z" } }, "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\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:25.492800Z", "iopub.status.busy": "2025-03-24T22:25:25.491953Z", "iopub.status.idle": "2025-03-24T22:25:25.612965Z", "shell.execute_reply": "2025-03-24T22:25:25.612071Z" } }, "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/a31efaeddc6c0746d9d331f2948fb8ec821d73ac" ], "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-calo-single-qa/8112/" ], "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-calo-single-qa/8112/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", "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": 6, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:25.616946Z", "iopub.status.busy": "2025-03-24T22:25:25.616484Z", "iopub.status.idle": "2025-03-24T22:25:26.241687Z", "shell.execute_reply": "2025-03-24T22:25:26.240506Z" }, "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": 7, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:26.245804Z", "iopub.status.busy": "2025-03-24T22:25:26.245573Z", "iopub.status.idle": "2025-03-24T22:25:27.149910Z", "shell.execute_reply": "2025-03-24T22:25:27.148888Z" } }, "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": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Inputs and file checks" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:27.152747Z", "iopub.status.busy": "2025-03-24T22:25:27.152527Z", "iopub.status.idle": "2025-03-24T22:25:27.258736Z", "shell.execute_reply": "2025-03-24T22:25:27.257972Z" } }, "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_pi+_pT30_Sum15_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_pi+_pT30_Sum15_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": 9, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:27.261241Z", "iopub.status.busy": "2025-03-24T22:25:27.261040Z", "iopub.status.idle": "2025-03-24T22:25:27.432407Z", "shell.execute_reply": "2025-03-24T22:25:27.431221Z" } }, "outputs": [ { "data": { "text/markdown": [ "Openning QA file at `G4sPHENIX_e-_pT4_Sum10_qa.root`" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/markdown": [ "Openning QA reference file at `reference/G4sPHENIX_e-_pT4_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\"Openning QA file at `{qa_file_name_new}`\"))\n", "ROOT.gInterpreter.ProcessLine(f\"TFile *qa_file_new = new TFile(\\\"{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\"Openning QA reference file at `{qa_file_name_ref}`\"))\n", " ROOT.gInterpreter.ProcessLine(f\"TFile *qa_file_ref = new TFile(\\\"{qa_file_name_ref}\\\");\")\n", "else:\n", " ROOT.gInterpreter.ProcessLine(f\"TFile *qa_file_ref = nullptr;\")\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:27.435409Z", "iopub.status.busy": "2025-03-24T22:25:27.435182Z", "iopub.status.idle": "2025-03-24T22:25:27.564919Z", "shell.execute_reply": "2025-03-24T22:25:27.563797Z" }, "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\"<" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "\n", "{\n", " TCanvas *c1 = new TCanvas(\"QA_Draw_CEMC_G4Hit\", \"QA_Draw_CEMC_G4Hit\", 1800, 900);\n", " c1->Divide(4, 2);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " TH2F *h_QAG4Sim_CEMC_G4Hit_XY = (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_XY\", \"TH2F\");\n", " assert(h_QAG4Sim_CEMC_G4Hit_XY);\n", " h_QAG4Sim_CEMC_G4Hit_XY->GetYaxis()->SetTitleOffset(1.5);\n", " h_QAG4Sim_CEMC_G4Hit_XY->Draw(\"COLZ\");\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " TH2F *h_QAG4Sim_CEMC_G4Hit_RZ = (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_RZ\", \"TH2F\");\n", " assert(h_QAG4Sim_CEMC_G4Hit_RZ);\n", " h_QAG4Sim_CEMC_G4Hit_RZ->GetYaxis()->SetTitleOffset(1.5);\n", " h_QAG4Sim_CEMC_G4Hit_RZ->Draw(\"COLZ\");\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection->ProjectionX(\n", " \"qa_file_new_h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection_px\");\n", "\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection);\n", "\n", " proj_ref = h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection->ProjectionX(\n", " \"qa_file_ref_h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection_px\");\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref, false, false); // not to use this histogram in KSTests\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection->ProjectionY(\n", " \"qa_file_new_h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection_py\");\n", "\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection);\n", "\n", " proj_ref = h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection->ProjectionY(\n", " \"qa_file_ref_h_QAG4Sim_CEMC_G4Hit_LateralTruthProjection_py\");\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref, false, false); // not to use this histogram in KSTests\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_HitTime\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(5);\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_HitTime\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(5);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Normalized energy per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref, false, false); // not to use this histogram in KSTests\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_FractionTruthEnergy\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(20);\n", " //h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_FractionTruthEnergy\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(20);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_VSF\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(2);\n", " //h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_VSF\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(2);\n", " //h_ref->Sumw2();\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_FractionEMVisibleEnergy\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(4);\n", " //h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_G4Hit_FractionEMVisibleEnergy\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(4);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " c1->Draw();\n", "// PutInputFileName(c1, .04, qa_file_name_new, qa_file_name_ref);\n", " // SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);\n", " \n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## CEMC tower and clusters\n", "\n", "Check on towers and clusters" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:29.162215Z", "iopub.status.busy": "2025-03-24T22:25:29.161081Z", "iopub.status.idle": "2025-03-24T22:25:29.278002Z", "shell.execute_reply": "2025-03-24T22:25:29.276728Z" } }, "outputs": [], "source": [ "%jsroot on" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:29.282771Z", "iopub.status.busy": "2025-03-24T22:25:29.282250Z", "iopub.status.idle": "2025-03-24T22:25:29.610607Z", "shell.execute_reply": "2025-03-24T22:25:29.609706Z" } }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "
\n", "
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "\n", "\n", "{\n", " \n", " TCanvas *c1 = new TCanvas(\"QA_Draw_CEMC_TowerCluster\", \"QA_Draw_CEMC_TowerCluster\", 950, 600);\n", " c1->Divide(4, 2);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Tower_1x1\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Tower_1x1\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Normalized tower count per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Tower_3x3\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Tower_3x3\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Normalized tower count per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Tower_1x1_max\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(40);\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Tower_1x1_max\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(40);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Tower_4x4_max\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(40);\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Tower_4x4_max\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(40);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " TH2F *h_QAG4Sim_CEMC_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_CEMC_Cluster_LateralTruthProjection);\n", " h_QAG4Sim_CEMC_Cluster_LateralTruthProjection -> SetDirectory(nullptr);\n", " \n", " h_QAG4Sim_CEMC_Cluster_LateralTruthProjection->GetYaxis()->SetTitleOffset(\n", " 1.5);\n", " h_QAG4Sim_CEMC_Cluster_LateralTruthProjection->GetXaxis()->SetRangeUser(-8,\n", " 8);\n", " h_QAG4Sim_CEMC_Cluster_LateralTruthProjection->GetYaxis()->SetRangeUser(-8,\n", " 8);\n", " h_QAG4Sim_CEMC_Cluster_LateralTruthProjection->Draw(\"COLZ\");\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_CEMC_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_CEMC_Cluster_LateralTruthProjection);\n", " h_QAG4Sim_CEMC_Cluster_LateralTruthProjection -> SetDirectory(nullptr);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_CEMC_Cluster_LateralTruthProjection->ProjectionX(\n", " \"qa_file_new_h_QAG4Sim_CEMC_Cluster_LateralTruthProjection_px\");\n", "\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_CEMC_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_CEMC_Cluster_LateralTruthProjection);\n", " h_QAG4Sim_CEMC_Cluster_LateralTruthProjection -> SetDirectory(nullptr);\n", "\n", " proj_ref = h_QAG4Sim_CEMC_Cluster_LateralTruthProjection->ProjectionX(\n", " \"qa_file_ref_h_QAG4Sim_CEMC_Cluster_LateralTruthProjection_px\");\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitleOffset(1.);\n", " proj_new->GetXaxis()->SetTitleOffset(1.);\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_CEMC_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_CEMC_Cluster_LateralTruthProjection);\n", " h_QAG4Sim_CEMC_Cluster_LateralTruthProjection -> SetDirectory(nullptr);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_CEMC_Cluster_LateralTruthProjection->ProjectionY(\n", " \"qa_file_new_h_QAG4Sim_CEMC_Cluster_LateralTruthProjection_py\");\n", "\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_CEMC_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_CEMC_Cluster_LateralTruthProjection);\n", " h_QAG4Sim_CEMC_Cluster_LateralTruthProjection -> SetDirectory(nullptr);\n", "\n", " proj_ref = h_QAG4Sim_CEMC_Cluster_LateralTruthProjection->ProjectionY(\n", " \"qa_file_ref_h_QAG4Sim_CEMC_Cluster_LateralTruthProjection_py\");\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitleOffset(1.);\n", " proj_new->GetXaxis()->SetTitleOffset(1.);\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Cluster_BestMatchERatio\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(2);\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CEMC_Cluster_BestMatchERatio\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(2);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " c1->Draw();\n", "// PutInputFileName(c1, .04, qa_file_name_new, qa_file_name_ref);\n", " // SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Inner HCal\n", "\n", "Inner HCal checks" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## HCalIn G4 hits\n", "\n", "Low level Geant4 simulation check for the Inner HCal" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:29.615763Z", "iopub.status.busy": "2025-03-24T22:25:29.615048Z", "iopub.status.idle": "2025-03-24T22:25:29.722700Z", "shell.execute_reply": "2025-03-24T22:25:29.721616Z" } }, "outputs": [], "source": [ "%jsroot off" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:29.726973Z", "iopub.status.busy": "2025-03-24T22:25:29.726631Z", "iopub.status.idle": "2025-03-24T22:25:32.117395Z", "shell.execute_reply": "2025-03-24T22:25:32.116137Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Warning in : ngroup=6 is not an exact divider of nbins=1000.\n", "Warning in : ngroup=6 is not an exact divider of nbins=1000.\n", "Warning in : ulast > fXmax, fXmax is used\n" ] }, { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "\n", "{\n", " \n", " TCanvas *c1 = new TCanvas(\"QA_Draw_HCALIN_G4Hit\", \"QA_Draw_HCALIN_G4Hit\",\n", " 1800, 900);\n", " c1->Divide(4, 2);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " TH2F *h_QAG4Sim_HCALIN_G4Hit_XY = (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_XY\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALIN_G4Hit_XY);\n", " h_QAG4Sim_HCALIN_G4Hit_XY->GetYaxis()->SetTitleOffset(1.5);\n", " h_QAG4Sim_HCALIN_G4Hit_XY->Draw(\"COLZ\");\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " TH2F *h_QAG4Sim_HCALIN_G4Hit_RZ = (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_RZ\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALIN_G4Hit_RZ);\n", " h_QAG4Sim_HCALIN_G4Hit_RZ->GetYaxis()->SetTitleOffset(1.5);\n", " h_QAG4Sim_HCALIN_G4Hit_RZ->Draw(\"COLZ\");\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection->ProjectionX(\n", " \"qa_file_new_h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection_px\");\n", "\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection);\n", "\n", " proj_ref = h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection->ProjectionX(\n", " \"qa_file_ref_h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection_px\");\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " // proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref, false, false); // not to use this histogram in KSTests\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection->ProjectionY(\n", " \"qa_file_new_h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection_py\");\n", "\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection);\n", "\n", " proj_ref = h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection->ProjectionY(\n", " \"qa_file_ref_h_QAG4Sim_HCALIN_G4Hit_LateralTruthProjection_py\");\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " // proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref, false, false); // not to use this histogram in KSTests\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_HitTime\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_HitTime\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Normalized energy per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref, false, false); // not to use this histogram in KSTests\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_FractionTruthEnergy\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(20);\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_FractionTruthEnergy\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(20);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_VSF\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(6);\n", " // h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_VSF\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(6);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " h_new->GetXaxis()->SetRangeUser(-0, .2);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_FractionEMVisibleEnergy\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(4);\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_G4Hit_FractionEMVisibleEnergy\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(4);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", "// PutInputFileName(c1, .04, qa_file_name_new, qa_file_name_ref);\n", "// SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);\n", " \n", " c1->Draw();\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## HCal In tower and clusters\n", "\n", "Check on towers and clusters" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:32.120354Z", "iopub.status.busy": "2025-03-24T22:25:32.120104Z", "iopub.status.idle": "2025-03-24T22:25:32.226969Z", "shell.execute_reply": "2025-03-24T22:25:32.226139Z" } }, "outputs": [], "source": [ "%jsroot on" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:32.231078Z", "iopub.status.busy": "2025-03-24T22:25:32.230575Z", "iopub.status.idle": "2025-03-24T22:25:32.439783Z", "shell.execute_reply": "2025-03-24T22:25:32.438922Z" } }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "
\n", "
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "{\n", " \n", " \n", " TCanvas *c1 = new TCanvas(\"QA_Draw_HCALIN_TowerCluster\",\n", " \"QA_Draw_HCALIN_TowerCluster\", 950, 600);\n", " c1->Divide(4, 2);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Tower_1x1\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Tower_1x1\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Normalized tower count per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Tower_3x3\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Tower_3x3\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Normalized tower count per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Tower_1x1_max\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(40);\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Tower_1x1_max\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(40);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Tower_4x4_max\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(40);\n", " //h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Tower_4x4_max\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(40);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " TH2F *h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection);\n", " h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->GetYaxis()->SetTitleOffset(\n", " 1.5);\n", " // h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->GetXaxis()->SetRangeUser(-5,\n", " // 5);\n", " // h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->GetYaxis()->SetRangeUser(-5,\n", " // 5);\n", " h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->Draw(\"COLZ\");\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->ProjectionX(\n", " \"qa_file_new_h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection_px\");\n", " proj_new->Rebin(4);\n", "\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection);\n", "\n", " proj_ref =\n", " h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->ProjectionX(\n", " \"qa_file_ref_h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection_px\");\n", " proj_ref->Rebin(4);\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitleOffset(1.);\n", " proj_new->GetXaxis()->SetTitleOffset(1.);\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " // proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->ProjectionY(\n", " \"qa_file_new_h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection_py\");\n", "\n", " proj_new->Rebin(4);\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection);\n", "\n", " proj_ref =\n", " h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection->ProjectionY(\n", " \"qa_file_ref_h_QAG4Sim_HCALIN_Cluster_LateralTruthProjection_py\");\n", " proj_ref->Rebin(4);\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitleOffset(1.);\n", " proj_new->GetXaxis()->SetTitleOffset(1.);\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " // proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Cluster_BestMatchERatio\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(2);\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALIN_Cluster_BestMatchERatio\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(2);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", "// PutInputFileName(c1, .04, qa_file_name_new, qa_file_name_ref);\n", "// SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);\n", " \n", " c1->Draw();\n", " \n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Outer HCal\n", "\n", "Outer HCal checks" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## HCalOut G4 hits\n", "\n", "Low level Geant4 simulation check for the Outer HCal" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:32.444665Z", "iopub.status.busy": "2025-03-24T22:25:32.444305Z", "iopub.status.idle": "2025-03-24T22:25:32.552392Z", "shell.execute_reply": "2025-03-24T22:25:32.551321Z" } }, "outputs": [], "source": [ "%jsroot off" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:32.557893Z", "iopub.status.busy": "2025-03-24T22:25:32.557207Z", "iopub.status.idle": "2025-03-24T22:25:34.212221Z", "shell.execute_reply": "2025-03-24T22:25:34.210809Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "{\n", " \n", " TCanvas *c1 = new TCanvas(\"QA_Draw_HCALOUT_G4Hit\", \"QA_Draw_HCALOUT_G4Hit\",\n", " 1800, 900);\n", " c1->Divide(4, 2);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " TH2F *h_QAG4Sim_HCALOUT_G4Hit_XY = (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_XY\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALOUT_G4Hit_XY);\n", " h_QAG4Sim_HCALOUT_G4Hit_XY->GetYaxis()->SetTitleOffset(1.5);\n", " h_QAG4Sim_HCALOUT_G4Hit_XY->Draw(\"COLZ\");\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " TH2F *h_QAG4Sim_HCALOUT_G4Hit_RZ = (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_RZ\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALOUT_G4Hit_RZ);\n", " h_QAG4Sim_HCALOUT_G4Hit_RZ->GetYaxis()->SetTitleOffset(1.5);\n", " h_QAG4Sim_HCALOUT_G4Hit_RZ->Draw(\"COLZ\");\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection->ProjectionX(\n", " \"qa_file_new_h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection_px\");\n", "\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection);\n", "\n", " proj_ref =\n", " h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection->ProjectionX(\n", " \"qa_file_ref_h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection_px\");\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " // proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref, false, false); // not to use this histogram in KSTests\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection->ProjectionY(\n", " \"qa_file_new_h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection_py\");\n", "\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection);\n", "\n", " proj_ref =\n", " h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection->ProjectionY(\n", " \"qa_file_ref_h_QAG4Sim_HCALOUT_G4Hit_LateralTruthProjection_py\");\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " // proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref, false, false); // not to use this histogram in KSTests\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_HitTime\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_HitTime\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Normalized energy per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref, false, false); // not to use this histogram in KSTests\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_FractionTruthEnergy\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(20);\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_FractionTruthEnergy\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(20);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_VSF\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(4);\n", " // h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_VSF\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(4);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_FractionEMVisibleEnergy\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(4);\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_G4Hit_FractionEMVisibleEnergy\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(4);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", "// PutInputFileName(c1, .04, qa_file_name_new, qa_file_name_ref);\n", "// SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);\n", " c1->Draw();\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## HCal Out tower and clusters\n", "\n", "Check on towers and clusters" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:34.215614Z", "iopub.status.busy": "2025-03-24T22:25:34.215123Z", "iopub.status.idle": "2025-03-24T22:25:34.323390Z", "shell.execute_reply": "2025-03-24T22:25:34.322255Z" } }, "outputs": [], "source": [ "%jsroot on" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:34.328124Z", "iopub.status.busy": "2025-03-24T22:25:34.326969Z", "iopub.status.idle": "2025-03-24T22:25:34.525501Z", "shell.execute_reply": "2025-03-24T22:25:34.524315Z" } }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "
\n", "
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "{\n", " \n", "\n", " TCanvas *c1 = new TCanvas(\"QA_Draw_HCALOUT_TowerCluster\",\n", " \"QA_Draw_HCALOUT_TowerCluster\", 950, 600);\n", " c1->Divide(4, 2);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Tower_1x1\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Tower_1x1\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Normalized tower count per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Tower_3x3\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Tower_3x3\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Normalized tower count per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Tower_1x1_max\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(40);\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Tower_1x1_max\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(40);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogx();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Tower_4x4_max\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(40);\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Tower_4x4_max\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(40);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " TH2F *h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection);\n", " h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection->GetYaxis()->SetTitleOffset(\n", " 1.5);\n", " // h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection->GetXaxis()->SetRangeUser(-5,\n", " // 5);\n", " // h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection->GetYaxis()->SetRangeUser(-5,\n", " // 5);\n", " h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection->Draw(\"COLZ\");\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection->ProjectionX(\n", " \"qa_file_new_h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection_px\");\n", " proj_new->Rebin(4);\n", "\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection);\n", "\n", " proj_ref =\n", " h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection->ProjectionX(\n", " \"qa_file_ref_h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection_px\");\n", " proj_ref->Rebin(4);\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitleOffset(1.);\n", " proj_new->GetXaxis()->SetTitleOffset(1.);\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " // proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection);\n", "\n", " TH1D *proj_new =\n", " h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection->ProjectionY(\n", " \"qa_file_new_h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection_py\");\n", "\n", " proj_new->Rebin(4);\n", " proj_new->Scale(1. / proj_new->GetSum());\n", "\n", " TH1D *proj_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " TH2F *h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection\", \"TH2F\");\n", " assert(h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection);\n", "\n", " proj_ref =\n", " h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection->ProjectionY(\n", " \"qa_file_ref_h_QAG4Sim_HCALOUT_Cluster_LateralTruthProjection_py\");\n", " proj_ref->Rebin(4);\n", " proj_ref->Scale(1. / proj_ref->GetSum());\n", " }\n", "\n", " proj_new->GetYaxis()->SetTitleOffset(1.);\n", " proj_new->GetXaxis()->SetTitleOffset(1.);\n", " proj_new->GetYaxis()->SetTitle(\"Normalized energy distribution\");\n", " // proj_new->GetXaxis()->SetRangeUser(-10, 10);\n", "\n", " DrawReference(proj_new, proj_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogy();\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Cluster_BestMatchERatio\", \"TH1F\");\n", " assert(h_new);\n", "\n", " h_new->Rebin(2);\n", " //h_new->Sumw2();\n", " h_new->Scale(1. / h_new->GetSum());\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_HCALOUT_Cluster_BestMatchERatio\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Rebin(2);\n", " h_ref->Scale(1. / h_ref->GetSum());\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Probability per bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", "// PutInputFileName(c1, .04, qa_file_name_new, qa_file_name_ref);\n", "// SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);\n", " c1->Draw();\n", " \n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Calorimeter Stack" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Cluster checks\n", "\n", "property for the sum of three clusters one in each layer of the calorimeter " ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:34.529177Z", "iopub.status.busy": "2025-03-24T22:25:34.528959Z", "iopub.status.idle": "2025-03-24T22:25:34.634851Z", "shell.execute_reply": "2025-03-24T22:25:34.633889Z" } }, "outputs": [], "source": [ "%jsroot on" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:34.637498Z", "iopub.status.busy": "2025-03-24T22:25:34.637137Z", "iopub.status.idle": "2025-03-24T22:25:34.789929Z", "shell.execute_reply": "2025-03-24T22:25:34.788755Z" } }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "
\n", "
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "{\n", " \n", " // obtain normalization\n", " double Nevent_new = 1;\n", " double Nevent_ref = 1;\n", "\n", " if (qa_file_new)\n", " {\n", " TH1D *h_norm = (TH1D *) qa_file_new->GetObjectChecked(\n", " TString(\"h_QAG4Sim_CalorimeterSum_Normalization\"), \"TH1D\");\n", " assert(h_norm);\n", "\n", " Nevent_new = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " }\n", " if (qa_file_ref)\n", " {\n", " TH1D *h_norm = (TH1D *) qa_file_ref->GetObjectChecked(\n", " TString(\"h_QAG4Sim_CalorimeterSum_Normalization\"), \"TH1D\");\n", " assert(h_norm);\n", "\n", " Nevent_ref = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " }\n", "\n", " TCanvas *c1 = new TCanvas(\"QA_Draw_Calorimeter_Sum_Cluster\",\n", " \"QA_Draw_Calorimeter_Sum_Cluster\", 950, 600);\n", " c1->Divide(3, 2);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_CalorimeterSum_Cluster_CEMC_HCALIN =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_Cluster_CEMC_HCALIN\", \"TH2F\");\n", " assert(h_QAG4Sim_CalorimeterSum_Cluster_CEMC_HCALIN);\n", " h_QAG4Sim_CalorimeterSum_Cluster_CEMC_HCALIN->GetYaxis()->SetTitleOffset(\n", " 1.5);\n", " h_QAG4Sim_CalorimeterSum_Cluster_CEMC_HCALIN->Draw(\"COLZ\");\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " {\n", " TH2F *h_QAG4Sim_CalorimeterSum_Cluster_CEMC_HCALIN_HCALOUT =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_Cluster_CEMC_HCALIN_HCALOUT\", \"TH2F\");\n", " assert(h_QAG4Sim_CalorimeterSum_Cluster_CEMC_HCALIN_HCALOUT);\n", " h_QAG4Sim_CalorimeterSum_Cluster_CEMC_HCALIN_HCALOUT->GetYaxis()->SetTitleOffset(\n", " 1.5);\n", " h_QAG4Sim_CalorimeterSum_Cluster_CEMC_HCALIN_HCALOUT->Draw(\"COLZ\");\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " // empty pannel\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_Cluster_Ratio_CEMC_HCALIN\", \"TH1F\");\n", " assert(h_new);\n", "\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / Nevent_new);\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_Cluster_Ratio_CEMC_HCALIN\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / Nevent_ref);\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Count / event / bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_Cluster_Ratio_CEMC_HCALIN_HCALOUT\", \"TH1F\");\n", " assert(h_new);\n", "\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / Nevent_new);\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_Cluster_Ratio_CEMC_HCALIN_HCALOUT\",\n", " \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / Nevent_ref);\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Count / event / bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_Cluster_EP\", \"TH1F\");\n", " assert(h_new);\n", "\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / Nevent_new);\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_Cluster_EP\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / Nevent_ref);\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Count / event / bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", "// PutInputFileName(c1, .04, qa_file_name_new, qa_file_name_ref);\n", "// SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);\n", " c1->Draw();\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Track projection matching\n", "\n", "*TODO: This QA module was broken since the change of the track projection module. Need to be Fixed*" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:34.793019Z", "iopub.status.busy": "2025-03-24T22:25:34.792605Z", "iopub.status.idle": "2025-03-24T22:25:34.920996Z", "shell.execute_reply": "2025-03-24T22:25:34.919884Z" } }, "outputs": [], "source": [ "%%cpp\n", "\n", "if (false)\n", "{\n", " \n", " // obtain normalization\n", " double Nevent_new = 1;\n", " double Nevent_ref = 1;\n", "\n", " // obtain normalization\n", " double Ntrack_new = 0;\n", " double Ntrack_ref = 0;\n", "\n", " if (qa_file_new)\n", " {\n", " TH1D *h_norm = (TH1D *) qa_file_new->GetObjectChecked(\n", " TString(\"h_QAG4Sim_CalorimeterSum_Normalization\"), \"TH1D\");\n", " assert(h_norm);\n", "\n", " Nevent_new = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " Ntrack_new = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Track\"));\n", " }\n", " if (qa_file_ref)\n", " {\n", " TH1D *h_norm = (TH1D *) qa_file_ref->GetObjectChecked(\n", " TString(\"h_QAG4Sim_CalorimeterSum_Normalization\"), \"TH1D\");\n", " assert(h_norm);\n", "\n", " Nevent_ref = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " Ntrack_ref = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Track\"));\n", " }\n", "\n", " vector subsystems;\n", " subsystems.push_back(\"CEMC\");\n", " subsystems.push_back(\"HCALIN\");\n", " subsystems.push_back(\"HCALOUT\");\n", "\n", " TCanvas *c1 = new TCanvas(\"QA_Draw_Calorimeter_Sum_TrackProj\",\n", " \"QA_Draw_Calorimeter_Sum_TrackProj\", 1100, 1100);\n", " c1->Divide(3, 3);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " for (int i = 0; i < subsystems.size(); ++i)\n", " {\n", " const TString subsystem(subsystems[i].c_str());\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " TH2F *h_QAG4Sim_CalorimeterSum_TrackProj =\n", " (TH2F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_\" + subsystem + \"_TrackProj\", \"TH2F\");\n", " assert(h_QAG4Sim_CalorimeterSum_TrackProj);\n", " h_QAG4Sim_CalorimeterSum_TrackProj->GetYaxis()->SetTitleOffset(1.5);\n", " h_QAG4Sim_CalorimeterSum_TrackProj->Draw(\"COLZ\");\n", "\n", " TH2F *h_QAG4Sim_CalorimeterSum_TrackProj_Ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_QAG4Sim_CalorimeterSum_TrackProj_Ref =\n", " (TH2F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_\" + subsystem + \"_TrackProj\",\n", " \"TH2F\");\n", " assert(h_QAG4Sim_CalorimeterSum_TrackProj);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " // x projections\n", " {\n", " TH1 *h_new = h_QAG4Sim_CalorimeterSum_TrackProj->ProjectionX(h_QAG4Sim_CalorimeterSum_TrackProj->GetName() + TString(\"_px\"));\n", "\n", " h_new->Scale(1. / Ntrack_new);\n", "\n", " TH1 *h_ref = NULL;\n", " if (h_QAG4Sim_CalorimeterSum_TrackProj_Ref)\n", " {\n", " h_ref = h_QAG4Sim_CalorimeterSum_TrackProj_Ref->ProjectionX(h_QAG4Sim_CalorimeterSum_TrackProj->GetName() + TString(\"_px_ref\"));\n", "\n", " h_ref->Scale(1. / Ntrack_ref);\n", " }\n", "\n", " h_new->GetXaxis()->SetTitleOffset(1.05);\n", " h_new->GetYaxis()->SetTitle(\"Energy / track / bin\");\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogz();\n", "\n", " // y projections\n", " {\n", " TH1 *h_new = h_QAG4Sim_CalorimeterSum_TrackProj->ProjectionY(h_QAG4Sim_CalorimeterSum_TrackProj->GetName() + TString(\"_py\"));\n", "\n", " h_new->Scale(1. / Ntrack_new);\n", "\n", " TH1 *h_ref = NULL;\n", " if (h_QAG4Sim_CalorimeterSum_TrackProj_Ref)\n", " {\n", " h_ref = h_QAG4Sim_CalorimeterSum_TrackProj_Ref->ProjectionY(h_QAG4Sim_CalorimeterSum_TrackProj->GetName() + TString(\"_py_ref\"));\n", "\n", " h_ref->Scale(1. / Ntrack_ref);\n", " }\n", "\n", " h_new->GetXaxis()->SetTitleOffset(1.05);\n", " h_new->GetYaxis()->SetTitle(\"Energy / track / bin\");\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", " }\n", "\n", "// PutInputFileName(c1, .03, qa_file_name_new, qa_file_name_ref);\n", "\n", "// SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);\n", " c1->Draw();\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Track projection $E/p$\n", "\n", "$E/p$ matching\n" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:34.924340Z", "iopub.status.busy": "2025-03-24T22:25:34.923939Z", "iopub.status.idle": "2025-03-24T22:25:35.075923Z", "shell.execute_reply": "2025-03-24T22:25:35.074723Z" } }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "
\n", "
\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%cpp\n", "{\n", " // obtain normalization\n", " double Nevent_new = 1;\n", " double Nevent_ref = 1;\n", "\n", " // obtain normalization\n", " double Ntrack_new = 0;\n", " double Ntrack_ref = 0;\n", "\n", " if (qa_file_new)\n", " {\n", " TH1D *h_norm = (TH1D *) qa_file_new->GetObjectChecked(\n", " TString(\"h_QAG4Sim_CalorimeterSum_Normalization\"), \"TH1D\");\n", " assert(h_norm);\n", "\n", " Nevent_new = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " Ntrack_new = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Track\"));\n", " }\n", " if (qa_file_ref)\n", " {\n", " TH1D *h_norm = (TH1D *) qa_file_ref->GetObjectChecked(\n", " TString(\"h_QAG4Sim_CalorimeterSum_Normalization\"), \"TH1D\");\n", " assert(h_norm);\n", "\n", " Nevent_ref = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Event\"));\n", " Ntrack_ref = h_norm->GetBinContent(h_norm->GetXaxis()->FindBin(\"Track\"));\n", " }\n", "\n", " TCanvas *c1 = new TCanvas(\"QA_Draw_Calorimeter_Sum_TrackProjEP\",\n", " \"QA_Draw_Calorimeter_Sum_TrackProjEP\", 900, 300);\n", " c1->Divide(3, 1);\n", " int idx = 1;\n", " TPad *p;\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " if (Ntrack_new > 0)\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_TrackProj_3x3Tower_EP\", \"TH1F\");\n", " assert(h_new);\n", "\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / Ntrack_new);\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_TrackProj_3x3Tower_EP\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / Ntrack_ref);\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Count / track / bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " if (Ntrack_new > 0)\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_TrackProj_5x5Tower_EP\", \"TH1F\");\n", " assert(h_new);\n", "\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / Ntrack_new);\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_TrackProj_5x5Tower_EP\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / Ntrack_ref);\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Count / track / bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", "\n", " p = (TPad *) c1->cd(idx++);\n", " c1->Update();\n", " p->SetLogy();\n", "\n", " if (Nevent_new > 0)\n", " {\n", " TH1F *h_new = (TH1F *) qa_file_new->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_Cluster_EP\", \"TH1F\");\n", " if (h_new)\n", " {\n", "// h_new->Sumw2();\n", " h_new->Scale(1. / Nevent_new);\n", "\n", " TH1F *h_ref = NULL;\n", " if (qa_file_ref)\n", " {\n", " h_ref = (TH1F *) qa_file_ref->GetObjectChecked(\n", " \"h_QAG4Sim_CalorimeterSum_Cluster_EP\", \"TH1F\");\n", " assert(h_ref);\n", "\n", " h_ref->Scale(1. / Nevent_ref);\n", " }\n", "\n", " h_new->GetYaxis()->SetTitleOffset(1.5);\n", " h_new->GetYaxis()->SetTitle(\"Count / event / bin\");\n", " // h_new->GetXaxis()->SetRangeUser(-0, .1);\n", "\n", " DrawReference(h_new, h_ref);\n", " }\n", " }\n", "\n", "// PutInputFileName(c1, 0.07, qa_file_name_new, qa_file_name_ref);\n", "// SaveCanvas(c1, TString(qa_file_name_new) + TString(c1->GetName()), true);\n", " c1->Draw();\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Summary statistics" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:35.078470Z", "iopub.status.busy": "2025-03-24T22:25:35.078220Z", "iopub.status.idle": "2025-03-24T22:25:35.220488Z", "shell.execute_reply": "2025-03-24T22:25:35.219396Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "This notebook contains 36 KSTets: combined Chi2/nDoF = 14.182 / 72, and combined __p-Value = 1__\n" ] } ], "source": [ "%%cpp\n", "\n", "KSTestSummary::getInstance()->make_summary_txt(\"QA-calorimeter.txt\");" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "execution": { "iopub.execute_input": "2025-03-24T22:25:35.223023Z", "iopub.status.busy": "2025-03-24T22:25:35.222812Z", "iopub.status.idle": "2025-03-24T22:25:35.351354Z", "shell.execute_reply": "2025-03-24T22:25:35.350264Z" } }, "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();" ] } ], "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 }