Skip to content

GitLab

Commit 70db16f2 authored by Viktor Klochkov's avatar Viktor Klochkov 👀 Committed by Volker Friese
Browse files

Do not use cuts by default in AnalysisTreeQA, install file with cuts

parent 153b0e87
Hide whitespace changes
Inline Side-by-side
Showing with 96 additions and 93 deletions
macro/CMakeLists.txt
View file @ 70db16f2
......@@ -41,6 +41,7 @@ Install(FILES C2F/.rootrc C2F/c2f_transport.C C2F/sis100_electron.tree.list
${CBMROOT_SOURCE_DIR}/macro/analysis/common/analysis_tree_converter/run_analysis_tree_maker.C
${CBMROOT_SOURCE_DIR}/macro/analysis/common/at_kfpf_interface/run_at_kfpf.C
${CBMROOT_SOURCE_DIR}/macro/analysis/common/qa/run_analysistree_qa.C
${CBMROOT_SOURCE_DIR}/macro/analysis/common/cuts/cbm_cuts.h
DESTINATION share/cbmroot/macro/c2f
)
Install(CODE "FILE(MAKE_DIRECTORY ${CMAKE_INSTALL_PREFIX}/share/cbmroot/macro/c2f/data)")
......
macro/analysis/common/qa/run_analysistree_qa.C
View file @ 70db16f2
......@@ -2,17 +2,23 @@
SPDX-License-Identifier: GPL-3.0-only
Authors: Viktor Klochkov [committer], Viktor Klochkov [committer] */
//#include <AnalysisTree/TaskManager.hpp>
//#include "AnalysisTree/Cuts.hpp"
//#include "src/EntryConfig.hpp"
//#include "src/Task.hpp"
//#include "src/Utils.hpp"
#include "../cuts/cbm_cuts.h"
typedef AnalysisTree::QA::EntryConfig::PlotType PlotType;
using AnalysisTree::QA::gNbins;
/** @brief run_analysistree_qa
** @param filelist Filefist (text file) of input AnalysisTree files
** @param is_single_file if true, instead of filelist a single ROOT file will be used as input
**
** Macro to run AnalysisTreeQA package (https://github.com/HeavyIonAnalysis/AnalysisTreeQA)
** Produces an output ROOT file with specified histograms / TProfiles.
** Examples how to add plots could be found here:
** https://github.com/HeavyIonAnalysis/AnalysisTreeQA/blob/master/examples/example.cpp
** To add event cuts:
** task->SetEventCuts(EventCuts);
** where EventCuts is AnalysisTree::Cuts* object, for example
** GetCbmEventCuts("RecEventHeader") from macro/analysis/common/cuts/cbm_cuts.h
** To apply a cut on some branch, for example select only primiry MC-tracks:
** task->AddBranchCut(GetCbmMcTracksCuts("SimParticles"));
** or apply quality cuts on STS tracks:
** task->AddBranchCut(GetCbmTrackCuts("RecTracks"));
**/
using namespace AnalysisTree;
......@@ -50,10 +56,6 @@ void run_analysistree_qa(std::string filelist, bool is_single_file)
auto* task = new QA::Task;
task->SetOutputFileName("cbm_qa.root");
task->SetEventCuts(GetCbmEventCuts("RecEventHeader"));
task->AddBranchCut(GetCbmMcTracksCuts("SimParticles"));
task->AddBranchCut(GetCbmTrackCuts("RecTracks"));
RichRingsQA(*task);
TrdTracksQA(*task);
// KFPFTracksQA(*task);
......@@ -83,39 +85,39 @@ void TrdTracksQA(QA::Task& task)
AddTrackQA(&task, trd_tracks);
AddTracksMatchQA(&task, trd_tracks, rec_tracks);
task.AddH1({"TRD energy loss in 1st station, keV", {trd_tracks, "energy_loss_0"}, {gNbins, 0, 50}});
task.AddH1({"TRD energy loss in 2nd station", {trd_tracks, "energy_loss_1"}, {gNbins, 0, 50}});
task.AddH1({"TRD energy loss in 3rd station", {trd_tracks, "energy_loss_2"}, {gNbins, 0, 50}});
task.AddH1({"TRD energy loss in 4th station", {trd_tracks, "energy_loss_3"}, {gNbins, 0, 50}});
task.AddH1({"TRD energy loss in 1st station, keV", {trd_tracks, "energy_loss_0"}, {QA::gNbins, 0, 50}});
task.AddH1({"TRD energy loss in 2nd station", {trd_tracks, "energy_loss_1"}, {QA::gNbins, 0, 50}});
task.AddH1({"TRD energy loss in 3rd station", {trd_tracks, "energy_loss_2"}, {QA::gNbins, 0, 50}});
task.AddH1({"TRD energy loss in 4th station", {trd_tracks, "energy_loss_3"}, {QA::gNbins, 0, 50}});
task.AddH1({"Number of hits in TRD", {trd_tracks, "n_hits"}, {6, 0, 6}});
task.AddH1({"PID Likelihood, e^{-}", {trd_tracks, "pid_like_e"}, {gNbins, -1, 1}});
task.AddH1({"PID Likelihood, #pi", {trd_tracks, "pid_like_pi"}, {gNbins, -1, 1}});
task.AddH1({"PID Likelihood, K", {trd_tracks, "pid_like_k"}, {gNbins, -1, 1}});
task.AddH1({"PID Likelihood, p", {trd_tracks, "pid_like_p"}, {gNbins, -1, 1}});
task.AddH1({"PID Likelihood, e^{-}", {trd_tracks, "pid_like_e"}, {QA::gNbins, -1, 1}});
task.AddH1({"PID Likelihood, #pi", {trd_tracks, "pid_like_pi"}, {QA::gNbins, -1, 1}});
task.AddH1({"PID Likelihood, K", {trd_tracks, "pid_like_k"}, {QA::gNbins, -1, 1}});
task.AddH1({"PID Likelihood, p", {trd_tracks, "pid_like_p"}, {QA::gNbins, -1, 1}});
task.AddH1({"#chi^{2}/NDF", {trd_tracks, "chi2_ov_ndf"}, {gNbins, 0, 30}});
task.AddH1({"p_{T}^{last} (GeV/c)", {trd_tracks, "pT_out"}, {gNbins, 0, 10}});
task.AddH1({"p^{last} (GeV/c)", {trd_tracks, "p_out"}, {gNbins, 0, 10}});
task.AddH1({"#chi^{2}/NDF", {trd_tracks, "chi2_ov_ndf"}, {QA::gNbins, 0, 30}});
task.AddH1({"p_{T}^{last} (GeV/c)", {trd_tracks, "pT_out"}, {QA::gNbins, 0, 10}});
task.AddH1({"p^{last} (GeV/c)", {trd_tracks, "p_out"}, {QA::gNbins, 0, 10}});
}
void RichRingsQA(QA::Task& task)
{
task.AddH1({"RICh ring x-position (cm)", {rich_rings, "x"}, {gNbins, -100, 100}});
task.AddH1({"RICh ring y-position (cm)", {rich_rings, "y"}, {gNbins, -250, 250}});
task.AddH2({"RICh ring x-position (cm)", {rich_rings, "x"}, {gNbins, -100, 100}},
{"RICh ring y-position (cm)", {rich_rings, "y"}, {gNbins, -250, 250}});
task.AddH1({"RICh ring x-position (cm)", {rich_rings, "x"}, {QA::gNbins, -100, 100}});
task.AddH1({"RICh ring y-position (cm)", {rich_rings, "y"}, {QA::gNbins, -250, 250}});
task.AddH2({"RICh ring x-position (cm)", {rich_rings, "x"}, {QA::gNbins, -100, 100}},
{"RICh ring y-position (cm)", {rich_rings, "y"}, {QA::gNbins, -250, 250}});
task.AddH1({"Ring radius", {rich_rings, "radius"}, {gNbins, 0, 10}});
task.AddH1({"Ring radius", {rich_rings, "radius"}, {QA::gNbins, 0, 10}});
task.AddH1({"n_hits", {rich_rings, "n_hits"}, {gNbins, 0, 60}});
task.AddH1({"n_hits_on_ring", {rich_rings, "n_hits_on_ring"}, {gNbins, 0, 100}});
task.AddH1({"axis_a", {rich_rings, "axis_a"}, {gNbins, 0, 10}});
task.AddH1({"axis_b", {rich_rings, "axis_b"}, {gNbins, 0, 10}});
task.AddH1({"n_hits", {rich_rings, "n_hits"}, {QA::gNbins, 0, 60}});
task.AddH1({"n_hits_on_ring", {rich_rings, "n_hits_on_ring"}, {QA::gNbins, 0, 100}});
task.AddH1({"axis_a", {rich_rings, "axis_a"}, {QA::gNbins, 0, 10}});
task.AddH1({"axis_b", {rich_rings, "axis_b"}, {QA::gNbins, 0, 10}});
task.AddH1({"chi2_ov_ndf", {rich_rings, "chi2_ov_ndf"}, {gNbins, 0, 1}});
task.AddH1({"phi_ellipse", {rich_rings, "phi_ellipse"}, {gNbins, -3.2, 3.2}});
task.AddH1({"chi2_ov_ndf", {rich_rings, "chi2_ov_ndf"}, {QA::gNbins, 0, 1}});
task.AddH1({"phi_ellipse", {rich_rings, "phi_ellipse"}, {QA::gNbins, -3.2, 3.2}});
}
void VertexTracksQA(QA::Task& task)
......@@ -126,33 +128,33 @@ void VertexTracksQA(QA::Task& task)
Variable chi2_over_ndf("chi2_ndf", {{rec_tracks, "chi2"}, {rec_tracks, "ndf"}},
[](std::vector<double>& var) { return var.at(0) / var.at(1); });
task.AddH1({"DCA_{x}, cm", {rec_tracks, "dcax"}, {gNbins, -1, 1}});
task.AddH1({"DCA_{y}, cm", {rec_tracks, "dcay"}, {gNbins, -1, 1}});
task.AddH1({"DCA_{z}, cm", {rec_tracks, "dcaz"}, {gNbins, -1, 1}});
task.AddH1({"DCA_{x}, cm", {rec_tracks, "dcax"}, {QA::gNbins, -1, 1}});
task.AddH1({"DCA_{y}, cm", {rec_tracks, "dcay"}, {QA::gNbins, -1, 1}});
task.AddH1({"DCA_{z}, cm", {rec_tracks, "dcaz"}, {QA::gNbins, -1, 1}});
task.AddH1({"NDF", {rec_tracks, "ndf"}, {30, 0, 30}});
task.AddH1({"Number of hits (STS+MVD)", {rec_tracks, "nhits"}, {15, 0, 15}});
task.AddH1({"Number of hits (MVD)", {rec_tracks, "nhits_mvd"}, {5, 0, 5}});
task.AddH1({"#chi^{2}_{vertex}", {rec_tracks, "vtx_chi2"}, {500, 0, 100}});
task.AddH1({"#chi^{2}/NDF", chi2_over_ndf, {gNbins, 0, 10}});
task.AddH2({"DCA_{x}, cm", {rec_tracks, "dcax"}, {gNbins, -1, 1}},
{"DCA_{y}, cm", {rec_tracks, "dcay"}, {gNbins, -1, 1}});
task.AddH1({"#chi^{2}/NDF", chi2_over_ndf, {QA::gNbins, 0, 10}});
task.AddH2({"DCA_{x}, cm", {rec_tracks, "dcax"}, {QA::gNbins, -1, 1}},
{"DCA_{y}, cm", {rec_tracks, "dcay"}, {QA::gNbins, -1, 1}});
}
void TofHitsQA(QA::Task& task)
{
task.AddH1({"TOF hit x-position (cm)", {tof_hits, "x"}, {gNbins, -600, 600}});
task.AddH1({"TOF hit y-position (cm)", {tof_hits, "y"}, {gNbins, -400, 400}});
task.AddH1({"TOF hit z-position (cm)", {tof_hits, "z"}, {gNbins, 600, 800}});
task.AddH1({"TOF hit x-position (cm)", {tof_hits, "x"}, {QA::gNbins, -600, 600}});
task.AddH1({"TOF hit y-position (cm)", {tof_hits, "y"}, {QA::gNbins, -400, 400}});
task.AddH1({"TOF hit z-position (cm)", {tof_hits, "z"}, {QA::gNbins, 600, 800}});
task.AddH2({"TOF hit x-position (cm)", {tof_hits, "x"}, {gNbins, -600, 600}},
{"TOF hit y-position (cm)", {tof_hits, "y"}, {gNbins, -600, 600}});
task.AddH2({"TOF hit x-position (cm)", {tof_hits, "x"}, {QA::gNbins, -600, 600}},
{"TOF hit y-position (cm)", {tof_hits, "y"}, {QA::gNbins, -600, 600}});
Variable qp_sts("qp_reco", {{rec_tracks, "q"}, {rec_tracks, "p"}},
[](std::vector<double>& qp) { return qp.at(0) * qp.at(1); });
task.AddH2({"sign(q)*p, GeV/c", qp_sts, {gNbins, -10, 10}},
{"m^{2}, GeV^{2}/c^{2}", {tof_hits, "mass2"}, {gNbins, -1, 2}});
task.AddH2({"sign(q)*p STS, GeV/c", qp_sts, {gNbins, -10, 10}},
{"sign(q)*p TOF, GeV/c", {tof_hits, "qp_tof"}, {gNbins, -10, 10}});
task.AddH2({"sign(q)*p, GeV/c", qp_sts, {QA::gNbins, -10, 10}},
{"m^{2}, GeV^{2}/c^{2}", {tof_hits, "mass2"}, {QA::gNbins, -1, 2}});
task.AddH2({"sign(q)*p STS, GeV/c", qp_sts, {QA::gNbins, -10, 10}},
{"sign(q)*p TOF, GeV/c", {tof_hits, "qp_tof"}, {QA::gNbins, -10, 10}});
SimpleCut sc_protons = EqualsCut("SimParticles.pid", 2212);
SimpleCut sc_prim = EqualsCut("SimParticles.mother_id", -1);
......@@ -175,36 +177,36 @@ void SimParticlesQA(QA::Task& task) { AddParticleQA(&task, sim_particles); }
void SimEventHeaderQA(QA::Task& task)
{
task.AddH1({"x_{vertex}^{MC} (cm)", {sim_event_header, "vtx_x"}, {gNbins, -1, 1}});
task.AddH1({"y_{vertex}^{MC} (cm)", {sim_event_header, "vtx_y"}, {gNbins, -1, 1}});
task.AddH1({"z_{vertex}^{MC} (cm)", {sim_event_header, "vtx_z"}, {gNbins, -1, 1}});
task.AddH1({"b (fm)", {sim_event_header, "b"}, {gNbins, 0, 20}});
task.AddH1({"#Psi_{RP}", {sim_event_header, "psi_RP"}, {gNbins, 0, 6.5}});
task.AddH2({"x_{vertex}^{MC} (cm)", {sim_event_header, "vtx_x"}, {gNbins, -1, 1}},
{"y_{vertex}^{MC} (cm)", {sim_event_header, "vtx_y"}, {gNbins, -1, 1}});
task.AddH1({"x_{vertex}^{MC} (cm)", {sim_event_header, "vtx_x"}, {QA::gNbins, -1, 1}});
task.AddH1({"y_{vertex}^{MC} (cm)", {sim_event_header, "vtx_y"}, {QA::gNbins, -1, 1}});
task.AddH1({"z_{vertex}^{MC} (cm)", {sim_event_header, "vtx_z"}, {QA::gNbins, -1, 1}});
task.AddH1({"b (fm)", {sim_event_header, "b"}, {QA::gNbins, 0, 20}});
task.AddH1({"#Psi_{RP}", {sim_event_header, "psi_RP"}, {QA::gNbins, 0, 6.5}});
task.AddH2({"x_{vertex}^{MC} (cm)", {sim_event_header, "vtx_x"}, {QA::gNbins, -1, 1}},
{"y_{vertex}^{MC} (cm)", {sim_event_header, "vtx_y"}, {QA::gNbins, -1, 1}});
}
void RecEventHeaderQA(QA::Task& task)
{
task.AddH1({"x_{vertex} (cm)", {rec_event_header, "vtx_x"}, {gNbins, -1, 1}});
task.AddH1({"y_{vertex} (cm)", {rec_event_header, "vtx_y"}, {gNbins, -1, 1}});
task.AddH1({"z_{vertex} (cm)", {rec_event_header, "vtx_z"}, {gNbins, -1, 1}});
task.AddH1({"#chi^{2}_{vertex fit}", {rec_event_header, "vtx_chi2"}, {gNbins, 0, 5}});
task.AddH1({"x_{vertex} (cm)", {rec_event_header, "vtx_x"}, {QA::gNbins, -1, 1}});
task.AddH1({"y_{vertex} (cm)", {rec_event_header, "vtx_y"}, {QA::gNbins, -1, 1}});
task.AddH1({"z_{vertex} (cm)", {rec_event_header, "vtx_z"}, {QA::gNbins, -1, 1}});
task.AddH1({"#chi^{2}_{vertex fit}", {rec_event_header, "vtx_chi2"}, {QA::gNbins, 0, 5}});
task.AddH1({"E_{PSD} (GeV)", {rec_event_header, "Epsd"}, {gNbins, 0, 60}});
task.AddH1({"E_{PSD} (GeV)", {rec_event_header, "Epsd"}, {QA::gNbins, 0, 60}});
task.AddH1({"M_{tracks}", {rec_event_header, "M"}, {800, 0, 800}});
task.AddH1({"Event ID", {rec_event_header, "evt_id"}, {gNbins, 0, 2000}});
task.AddH1({"Event ID", {rec_event_header, "evt_id"}, {QA::gNbins, 0, 2000}});
task.AddH2({"x_{vertex} (cm)", {rec_event_header, "vtx_x"}, {gNbins, -1, 1}},
{"y_{vertex} (cm)", {rec_event_header, "vtx_y"}, {gNbins, -1, 1}});
task.AddH2({"x_{vertex} (cm)", {rec_event_header, "vtx_x"}, {QA::gNbins, -1, 1}},
{"y_{vertex} (cm)", {rec_event_header, "vtx_y"}, {QA::gNbins, -1, 1}});
task.AddH2({"x_{vertex} (cm)", {rec_event_header, "vtx_x"}, {gNbins, -1, 1}},
{"x_{vertex} (cm)", {sim_event_header, "vtx_x"}, {gNbins, -1, 1}});
task.AddH2({"y_{vertex} (cm)", {rec_event_header, "vtx_y"}, {gNbins, -1, 1}},
{"y_{vertex} (cm)", {sim_event_header, "vtx_y"}, {gNbins, -1, 1}});
task.AddH2({"z_{vertex} (cm)", {rec_event_header, "vtx_z"}, {gNbins, -1, 1}},
{"z_{vertex} (cm)", {sim_event_header, "vtx_z"}, {gNbins, -1, 1}});
task.AddH2({"x_{vertex} (cm)", {rec_event_header, "vtx_x"}, {QA::gNbins, -1, 1}},
{"x_{vertex} (cm)", {sim_event_header, "vtx_x"}, {QA::gNbins, -1, 1}});
task.AddH2({"y_{vertex} (cm)", {rec_event_header, "vtx_y"}, {QA::gNbins, -1, 1}},
{"y_{vertex} (cm)", {sim_event_header, "vtx_y"}, {QA::gNbins, -1, 1}});
task.AddH2({"z_{vertex} (cm)", {rec_event_header, "vtx_z"}, {QA::gNbins, -1, 1}},
{"z_{vertex} (cm)", {sim_event_header, "vtx_z"}, {QA::gNbins, -1, 1}});
}
void EfficiencyMaps(QA::Task& task)
......@@ -227,19 +229,19 @@ void EfficiencyMaps(QA::Task& task)
Cuts* mc_pions_neg = new Cuts("McPionsNeg", {EqualsCut({sim_particles + ".pid"}, -211)});
Cuts* mc_pions_pos = new Cuts("McPionsPos", {EqualsCut({sim_particles + ".pid"}, -211)});
task.AddH2({"#it{y}_{Lab}", {sim_particles, "rapidity"}, {gNbins, -1, 5}},
{"p_{T}, GeV/c", {sim_particles, "pT"}, {gNbins, 0, 2}}, mc_protons);
task.AddH2({"#it{y}_{Lab}", proton_y, {gNbins, -1, 5}}, {"p_{T}, GeV/c", {rec_tracks, "pT"}, {gNbins, 0, 2}},
task.AddH2({"#it{y}_{Lab}", {sim_particles, "rapidity"}, {QA::gNbins, -1, 5}},
{"p_{T}, GeV/c", {sim_particles, "pT"}, {QA::gNbins, 0, 2}}, mc_protons);
task.AddH2({"#it{y}_{Lab}", proton_y, {QA::gNbins, -1, 5}}, {"p_{T}, GeV/c", {rec_tracks, "pT"}, {QA::gNbins, 0, 2}},
mc_protons);
task.AddH2({"#it{y}_{Lab}", {sim_particles, "rapidity"}, {gNbins, -1, 5}},
{"p_{T}, GeV/c", {sim_particles, "pT"}, {gNbins, 0, 2}}, mc_pions_neg);
task.AddH2({"#it{y}_{Lab}", pion_y, {gNbins, -1, 5}}, {"p_{T}, GeV/c", {rec_tracks, "pT"}, {gNbins, 0, 2}},
task.AddH2({"#it{y}_{Lab}", {sim_particles, "rapidity"}, {QA::gNbins, -1, 5}},
{"p_{T}, GeV/c", {sim_particles, "pT"}, {QA::gNbins, 0, 2}}, mc_pions_neg);
task.AddH2({"#it{y}_{Lab}", pion_y, {QA::gNbins, -1, 5}}, {"p_{T}, GeV/c", {rec_tracks, "pT"}, {QA::gNbins, 0, 2}},
mc_pions_neg);
task.AddH2({"#it{y}_{Lab}", {sim_particles, "rapidity"}, {gNbins, -1, 5}},
{"p_{T}, GeV/c", {sim_particles, "pT"}, {gNbins, 0, 2}}, mc_pions_pos);
task.AddH2({"#it{y}_{Lab}", pion_y, {gNbins, -1, 5}}, {"p_{T}, GeV/c", {rec_tracks, "pT"}, {gNbins, 0, 2}},
task.AddH2({"#it{y}_{Lab}", {sim_particles, "rapidity"}, {QA::gNbins, -1, 5}},
{"p_{T}, GeV/c", {sim_particles, "pT"}, {QA::gNbins, 0, 2}}, mc_pions_pos);
task.AddH2({"#it{y}_{Lab}", pion_y, {QA::gNbins, -1, 5}}, {"p_{T}, GeV/c", {rec_tracks, "pT"}, {QA::gNbins, 0, 2}},
mc_pions_pos);
}
......@@ -248,22 +250,22 @@ void KFPFTracksQA(QA::Task& task)
const std::vector<std::string> field_par_names_ {"cx0", "cx1", "cx2", "cy1", "cy2", "cz0", "cz1", "cz2"};
const std::vector<std::string> cov_names_ {"cov1", "cov2", "cov3", "cov4", "cov5", "cov6", "cov7", "cov8",
"cov9", "cov10", "cov11", "cov12", "cov13", "cov14", "cov15"};
// KFPF tracks
task.AddH1({"x, cm", {rec_tracks, "x"}, {gNbins, -10, 10}});
task.AddH1({"y, cm", {rec_tracks, "y"}, {gNbins, -10, 10}});
task.AddH1({"z, cm", {rec_tracks, "z"}, {gNbins, 0, 40}});
task.AddH1({"t_{x}", {rec_tracks, "tx"}, {gNbins, -2, 2}});
task.AddH1({"t_{y}", {rec_tracks, "ty"}, {gNbins, -2, 2}});
task.AddH1({"q*p, GeV/c", {rec_tracks, "qp"}, {gNbins, -10, 10}});
task.AddH1({"x, cm", {rec_tracks, "x"}, {QA::gNbins, -10, 10}});
task.AddH1({"y, cm", {rec_tracks, "y"}, {QA::gNbins, -10, 10}});
task.AddH1({"z, cm", {rec_tracks, "z"}, {QA::gNbins, 0, 40}});
task.AddH1({"t_{x}", {rec_tracks, "tx"}, {QA::gNbins, -2, 2}});
task.AddH1({"t_{y}", {rec_tracks, "ty"}, {QA::gNbins, -2, 2}});
task.AddH1({"q*p, GeV/c", {rec_tracks, "qp"}, {QA::gNbins, -10, 10}});
for (const auto& field_par_name : field_par_names_)
task.AddH1({field_par_name, {rec_tracks, field_par_name}, {gNbins, -1, 1}});
task.AddH1({field_par_name, {rec_tracks, field_par_name}, {QA::gNbins, -1, 1}});
for (const auto& cov_name : cov_names_)
task.AddH1({cov_name, {rec_tracks, cov_name}, {1000, -.1, .1}});
task.AddH1({"cy0", {rec_tracks, "cy0"}, {gNbins, -12, -8}});
task.AddH1({"z0", {rec_tracks, "z0"}, {gNbins, 0, 40}});
task.AddH1({"cy0", {rec_tracks, "cy0"}, {QA::gNbins, -12, -8}});
task.AddH1({"z0", {rec_tracks, "z0"}, {QA::gNbins, 0, 40}});
}
int main(int argc, char** argv)
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment