Skip to content
Snippets Groups Projects
Commit 70db16f2 authored by Viktor Klochkov's avatar Viktor Klochkov :eyes: Committed by Volker Friese
Browse files

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

parent 153b0e87
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
macro/CMakeLists.txt
+ 1
− 0
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
+ 95
− 93
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)
......
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