From cb38bb19ecca84031f7134845d4de17c763afd5f Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Mon, 7 Apr 2025 14:31:11 +0200 Subject: [PATCH 1/9] [Benchmarks] Introduce analysis benhcmark tasks --- Benchmarks/CMakeLists.txt | 27 ++++++++ Benchmarks/include/tables.h | 36 +++++++++++ .../src/configurable-expression-column.cxx | 44 +++++++++++++ Benchmarks/src/dynamic-column-func.cxx | 64 +++++++++++++++++++ Benchmarks/src/dynamic-column.cxx | 37 +++++++++++ CMakeLists.txt | 1 + 6 files changed, 209 insertions(+) create mode 100644 Benchmarks/CMakeLists.txt create mode 100644 Benchmarks/include/tables.h create mode 100644 Benchmarks/src/configurable-expression-column.cxx create mode 100644 Benchmarks/src/dynamic-column-func.cxx create mode 100644 Benchmarks/src/dynamic-column.cxx diff --git a/Benchmarks/CMakeLists.txt b/Benchmarks/CMakeLists.txt new file mode 100644 index 00000000000..42c833f81c7 --- /dev/null +++ b/Benchmarks/CMakeLists.txt @@ -0,0 +1,27 @@ +# Copyright 2019-2020 CERN and copyright holders of ALICE O2. +# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +# All rights not expressly granted are reserved. +# +# This software is distributed under the terms of the GNU General Public +# License v3 (GPL Version 3), copied verbatim in the file "COPYING". +# +# In applying this license CERN does not waive the privileges and immunities +# granted to it by virtue of its status as an Intergovernmental Organization +# or submit itself to any jurisdiction. + +include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include") + +o2physics_add_dpl_workflow(dynamic + SOURCES src/dynamic-column.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisBenchmark) + +o2physics_add_dpl_workflow(dynamic-func + SOURCES src/dynamic-column-func.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisBenchmark) + +o2physics_add_dpl_workflow(configurable-expression + SOURCES src/configurable-expression-column.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisBenchmark) diff --git a/Benchmarks/include/tables.h b/Benchmarks/include/tables.h new file mode 100644 index 00000000000..46c1b2bbac2 --- /dev/null +++ b/Benchmarks/include/tables.h @@ -0,0 +1,36 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +#include + +namespace o2::aod +{ +namespace extensions +{ +DECLARE_SOA_DYNAMIC_COLUMN(Direct, direct, [](float x, float y, float z, float t) -> float { return t * (x*x + y*y + z*z); }); +DECLARE_SOA_COLUMN(DirectM, directm, float); + +DECLARE_SOA_DYNAMIC_COLUMN(Indirect, indirect, [](float phi, float x, float y, float z, std::function const& f) -> float { return f(phi, x, y, z); }); +DECLARE_SOA_COLUMN(IndirectM, indirectm, float); + +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(Expr, expr, float, "Expr"); +} + +DECLARE_SOA_TABLE(ExtTracksD, "AOD", "TRKD", extensions::Direct); +DECLARE_SOA_TABLE(ExtTracksID, "AOD", "TRKID", extensions::Indirect); + +DECLARE_SOA_TABLE(ExtTracksDM, "AOD", "TRKDM", extensions::DirectM); +DECLARE_SOA_TABLE(ExtTracksIDM, "AOD", "TRKIDM", extensions::IndirectM); + +DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(TracksE, TracksIU, "TRKE", extensions::Expr); + +using TracksD = soa::Join; +using TracksID = soa::Join; +} diff --git a/Benchmarks/src/configurable-expression-column.cxx b/Benchmarks/src/configurable-expression-column.cxx new file mode 100644 index 00000000000..9e062758c47 --- /dev/null +++ b/Benchmarks/src/configurable-expression-column.cxx @@ -0,0 +1,44 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include "Framework/runDataProcessing.h" +#include "Framework/AnalysisTask.h" + +#include "tables.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +struct ProduceExression { + Defines te; + // bin lower bounds + the rightmost upper bound + Configurable> binning{"binning", {0, o2::constants::math::PIHalf, o2::constants::math::PI, o2::constants::math::PI + o2::constants::math::PIHalf, o2::constants::math::TwoPI}, "Phi binning"}; + // parameters for the function as a flat array, grouped by parameter + Configurable> parameters{"parameters", {1.0, 1.1, 1.2, 1.3, // par 0 + 2.0, 2.1, 2.2, 2.3, // par 1 + 3.0, 3.1, 3.2, 3.3}, // par 2 + "Function parameters for each phi bin"}; + + void init(InitContext&) + { + // dummy function for benchmark (equivalent to dynamic-column-func.cxx) + te.projectors[0] = binned((std::vector)binning, + (std::vector)parameters, + aod::track::phi, nsqrt(par(0) * aod::track::x * aod::track::x + par(1) * aod::track::y * aod::track::y + par(2) * aod::track::z * aod::track::z), + LiteralNode{-1.f}); + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return {adaptAnalysisTask(cfgc)}; +} diff --git a/Benchmarks/src/dynamic-column-func.cxx b/Benchmarks/src/dynamic-column-func.cxx new file mode 100644 index 00000000000..5de8c3536d7 --- /dev/null +++ b/Benchmarks/src/dynamic-column-func.cxx @@ -0,0 +1,64 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include "Framework/runDataProcessing.h" +#include "Framework/AnalysisTask.h" + +#include "tables.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +struct ProduceDynamicExtensionFunc { + Produces etidm; + + std::function callable; + // bin lower bounds + the rightmost upper bound + Configurable> binning{"binning", {0, o2::constants::math::PIHalf, o2::constants::math::PI, o2::constants::math::PI + o2::constants::math::PIHalf, o2::constants::math::TwoPI}, "Phi binning"}; + // parameters for the function as a flat array, grouped by parameter + Configurable> parameters{"parameters", {1.0, 1.1, 1.2, 1.3, // par 0 + 2.0, 2.1, 2.2, 2.3, // par 1 + 3.0, 3.1, 3.2, 3.3}, // par 2 + "Function parameters for each phi bin"}; + + void init(InitContext&) + { + // dummy function for benchmark (equivalent to configurable-expression-column.cxx) + callable = [binning = (std::vector)binning, parameters = (std::vector)parameters](float phi, float x, float y, float z) -> float { + if (phi < binning[0]) { + return -1.f; + } + auto n = binning.size() - 1; + for (auto i = 0U; i < n; ++i) { + if (phi < binning[i + 1]) { + return std::sqrt(parameters[0 * n + i] * x * x + // + parameters[1 * n + i] * y * y + // + parameters[2 * n + i] * z * z); // + } + } + return -1.f; + }; + } + + void process(aod::TracksIU const& tracks) + { + auto tracksID = soa::Attach>(tracks); + for (auto& track : tracksID) { + etidm(track.indirect(callable)); + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return {adaptAnalysisTask(cfgc)}; +} diff --git a/Benchmarks/src/dynamic-column.cxx b/Benchmarks/src/dynamic-column.cxx new file mode 100644 index 00000000000..f08a7f36d3e --- /dev/null +++ b/Benchmarks/src/dynamic-column.cxx @@ -0,0 +1,37 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include "Framework/runDataProcessing.h" +#include "Framework/AnalysisTask.h" + +#include "tables.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +struct ProduceDynamicExtension { + Produces etdm; + Configurable factor{"factor", 1.0f, "Configurable factor"}; + + void process(aod::TracksIU const& tracks) + { + auto tracksD = soa::Attach>(tracks); + for (auto& track : tracksD) { + etdm(track.direct((float)factor)); + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return {adaptAnalysisTask(cfgc)}; +} diff --git a/CMakeLists.txt b/CMakeLists.txt index af18a4a16f2..33e7234d693 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -75,6 +75,7 @@ add_subdirectory(PWGUD) add_subdirectory(Tools) add_subdirectory(Tutorials) +add_subdirectory(Benchmarks) add_subdirectory(EventFiltering) add_subdirectory(Scripts) From 59a5900d97d40f9d7b0e8ed99b186ff1b841ec61 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Mon, 14 Apr 2025 10:41:50 +0000 Subject: [PATCH 2/9] Please consider the following formatting changes --- Benchmarks/include/tables.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Benchmarks/include/tables.h b/Benchmarks/include/tables.h index 46c1b2bbac2..36406548571 100644 --- a/Benchmarks/include/tables.h +++ b/Benchmarks/include/tables.h @@ -14,14 +14,14 @@ namespace o2::aod { namespace extensions { -DECLARE_SOA_DYNAMIC_COLUMN(Direct, direct, [](float x, float y, float z, float t) -> float { return t * (x*x + y*y + z*z); }); +DECLARE_SOA_DYNAMIC_COLUMN(Direct, direct, [](float x, float y, float z, float t) -> float { return t * (x * x + y * y + z * z); }); DECLARE_SOA_COLUMN(DirectM, directm, float); DECLARE_SOA_DYNAMIC_COLUMN(Indirect, indirect, [](float phi, float x, float y, float z, std::function const& f) -> float { return f(phi, x, y, z); }); DECLARE_SOA_COLUMN(IndirectM, indirectm, float); DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(Expr, expr, float, "Expr"); -} +} // namespace extensions DECLARE_SOA_TABLE(ExtTracksD, "AOD", "TRKD", extensions::Direct); DECLARE_SOA_TABLE(ExtTracksID, "AOD", "TRKID", extensions::Indirect); @@ -33,4 +33,4 @@ DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(TracksE, TracksIU, "TRKE", extensions::E using TracksD = soa::Join; using TracksID = soa::Join; -} +} // namespace o2::aod From ae6d149e3cd2e5755a2ecfff787e7dad22653ad7 Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Mon, 14 Apr 2025 13:05:43 +0200 Subject: [PATCH 3/9] add header guard --- Benchmarks/include/tables.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Benchmarks/include/tables.h b/Benchmarks/include/tables.h index 36406548571..f22f42254ac 100644 --- a/Benchmarks/include/tables.h +++ b/Benchmarks/include/tables.h @@ -8,6 +8,8 @@ // In applying this license CERN does not waive the privileges and immunities // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. +#ifndef O2PHYSICS_BENCHMARKS_INCLUDE_TABLES_H_ +#define O2PHYSICS_BENCHMARKS_INCLUDE_TABLES_H_ #include namespace o2::aod @@ -34,3 +36,4 @@ DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(TracksE, TracksIU, "TRKE", extensions::E using TracksD = soa::Join; using TracksID = soa::Join; } // namespace o2::aod +#endif From 86bb6f51297804616fbc71167ef3c16a3dcad47e Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Wed, 28 May 2025 11:09:45 +0200 Subject: [PATCH 4/9] add comparison of calib functions --- Benchmarks/CMakeLists.txt | 46 ++++--- Benchmarks/include/tables.h | 33 +++++ .../src/produce-dynamic-extension-calib.cxx | 107 ++++++++++++++++ ...cxx => produce-dynamic-extension-func.cxx} | 0 ...lumn.cxx => produce-dynamic-extension.cxx} | 0 Benchmarks/src/produce-expression-calib.cxx | 116 ++++++++++++++++++ ...sion-column.cxx => produce-expression.cxx} | 0 7 files changed, 284 insertions(+), 18 deletions(-) create mode 100644 Benchmarks/src/produce-dynamic-extension-calib.cxx rename Benchmarks/src/{dynamic-column-func.cxx => produce-dynamic-extension-func.cxx} (100%) rename Benchmarks/src/{dynamic-column.cxx => produce-dynamic-extension.cxx} (100%) create mode 100644 Benchmarks/src/produce-expression-calib.cxx rename Benchmarks/src/{configurable-expression-column.cxx => produce-expression.cxx} (100%) diff --git a/Benchmarks/CMakeLists.txt b/Benchmarks/CMakeLists.txt index 42c833f81c7..8c142e655b3 100644 --- a/Benchmarks/CMakeLists.txt +++ b/Benchmarks/CMakeLists.txt @@ -1,27 +1,37 @@ -# Copyright 2019-2020 CERN and copyright holders of ALICE O2. -# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +# Copyright 2019-2020 CERN and copyright holders of ALICE O2. See +# https://alice-o2.web.cern.ch/copyright for details of the copyright holders. # All rights not expressly granted are reserved. # -# This software is distributed under the terms of the GNU General Public -# License v3 (GPL Version 3), copied verbatim in the file "COPYING". +# This software is distributed under the terms of the GNU General Public License +# v3 (GPL Version 3), copied verbatim in the file "COPYING". # # In applying this license CERN does not waive the privileges and immunities -# granted to it by virtue of its status as an Intergovernmental Organization -# or submit itself to any jurisdiction. +# granted to it by virtue of its status as an Intergovernmental Organization or +# submit itself to any jurisdiction. include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include") -o2physics_add_dpl_workflow(dynamic - SOURCES src/dynamic-column.cxx - PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore - COMPONENT_NAME AnalysisBenchmark) +o2physics_add_dpl_workflow(produce-dynamic-extension + SOURCES src/produce-dynamic-extension.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisBenchmark) -o2physics_add_dpl_workflow(dynamic-func - SOURCES src/dynamic-column-func.cxx - PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore - COMPONENT_NAME AnalysisBenchmark) +o2physics_add_dpl_workflow(produce-dynamic-extension-func + SOURCES src/produce-dynamic-extension-func.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisBenchmark) -o2physics_add_dpl_workflow(configurable-expression - SOURCES src/configurable-expression-column.cxx - PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore - COMPONENT_NAME AnalysisBenchmark) +o2physics_add_dpl_workflow(produce-expression + SOURCES src/produce-expression.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisBenchmark) + +o2physics_add_dpl_workflow(produce-dynamic-extension-calib + SOURCES src/produce-dynamic-extension-calib.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::AnalysisCCDB + COMPONENT_NAME AnalysisBenchmark) + +o2physics_add_dpl_workflow(produce-expression-calib + SOURCES src/produce-expression-calib.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::AnalysisCCDB + COMPONENT_NAME AnalysisBenchmark) diff --git a/Benchmarks/include/tables.h b/Benchmarks/include/tables.h index f22f42254ac..bf86f71ef31 100644 --- a/Benchmarks/include/tables.h +++ b/Benchmarks/include/tables.h @@ -11,28 +11,61 @@ #ifndef O2PHYSICS_BENCHMARKS_INCLUDE_TABLES_H_ #define O2PHYSICS_BENCHMARKS_INCLUDE_TABLES_H_ #include +#include namespace o2::aod { namespace extensions { +// example generic functions +// 1. simple dynamic column and a column to be filled with the result DECLARE_SOA_DYNAMIC_COLUMN(Direct, direct, [](float x, float y, float z, float t) -> float { return t * (x * x + y * y + z * z); }); DECLARE_SOA_COLUMN(DirectM, directm, float); +// 2. arbitrary function dynamic column and a column to be filled with the result DECLARE_SOA_DYNAMIC_COLUMN(Indirect, indirect, [](float phi, float x, float y, float z, std::function const& f) -> float { return f(phi, x, y, z); }); DECLARE_SOA_COLUMN(IndirectM, indirectm, float); +// 3. arbitrary expression column placeholder DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(Expr, expr, float, "Expr"); + +// 4. example realistic values - corrected dE/dx +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealTPCSignalN, realTPCSignalN, float, "fRealTPCSignalN"); +DECLARE_SOA_COLUMN(RealTPCSignalNC, realTPCSignalNC, float); } // namespace extensions +// tables with simple and arbitrary function dynamic columns DECLARE_SOA_TABLE(ExtTracksD, "AOD", "TRKD", extensions::Direct); DECLARE_SOA_TABLE(ExtTracksID, "AOD", "TRKID", extensions::Indirect); +// tables to be filled with the results of the above DECLARE_SOA_TABLE(ExtTracksDM, "AOD", "TRKDM", extensions::DirectM); DECLARE_SOA_TABLE(ExtTracksIDM, "AOD", "TRKIDM", extensions::IndirectM); +// extended table with an arbitrary expression column DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(TracksE, TracksIU, "TRKE", extensions::Expr); +// intermediate values for the realistic calculation +namespace intermediate { +DECLARE_SOA_COLUMN(HRate, hRate, float); +DECLARE_SOA_COLUMN(ClampedTPCMult, clampedTPCmult, float); +DECLARE_SOA_COLUMN(Occupancy, occupancy, float); +DECLARE_SOA_COLUMN(Correction0, correction0, float); +} + +// intermediate table +DECLARE_SOA_TABLE(TracksTemporaryExtra, "AOD", "TRKTEMPEX", + intermediate::HRate, intermediate::ClampedTPCMult, intermediate::Occupancy, intermediate::Correction0, + aod::track::TPCSignal, aod::track::Signed1Pt, aod::track::Tgl); +using TracksQAEx = soa::Join; + +// final table +DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(TracksQACorrectedE, TracksQAEx, "TRKWTPCE", extensions::RealTPCSignalN); +using MoreTracksFinal = soa::Join; + +// final table for direct calculation +DECLARE_SOA_TABLE(TracksQACorrected, "AOD", "TPCEXT", extensions::RealTPCSignalNC); + using TracksD = soa::Join; using TracksID = soa::Join; } // namespace o2::aod diff --git a/Benchmarks/src/produce-dynamic-extension-calib.cxx b/Benchmarks/src/produce-dynamic-extension-calib.cxx new file mode 100644 index 00000000000..947d0274538 --- /dev/null +++ b/Benchmarks/src/produce-dynamic-extension-calib.cxx @@ -0,0 +1,107 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include +#include "Common/CCDB/ctpRateFetcher.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "tables.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +float fReal_fTPCSignalN(float mbb0R, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.019869f * mbb0R) + (0.0012031f * a1pt) + (-0.0031766f * atgl) + (-0.0058023f * atgl * mbb0R) + (0.00087494f * a1pt * mbb0R) + (0.0020074f * side) + (-0.0010434f * a1pt * a1pt) + (0.011812f)) * occ / 1.e3f + // + ((0.009032f * mbb0R) + (0.0011737f * a1pt) + (-0.0010241f * atgl) + (-0.0075789f * atgl * mbb0R) + (0.00029324f * a1pt * mbb0R) + (0.00052475f * side) + (-0.00045413f * a1pt * a1pt) + (0.0024879f)) * fOccTPCN + // + ((0.004255f * mbb0R) + (0.0011954f * a1pt) + (0.0054092f * atgl) + (-0.0033655f * atgl * mbb0R) + (0.00052243f * a1pt * mbb0R) + (-0.0002969f * side) + (-0.00074909f * a1pt * a1pt) + (-0.0075754f)) * fTrackOccMeanN + // + ((-0.07925f * mbb0R) + (-0.03737f * a1pt) + (0.0017054f * atgl) + (0.093686f * atgl * mbb0R) + (0.023925f * a1pt * mbb0R) + (-0.0083407f * side) + (0.00336f * a1pt * a1pt) + (1.0461f)); +}; + +float clamp(float value, float lo, float hi) +{ + return value < lo ? lo : (value > hi ? hi : value); +} + +struct ProduceDynamicExtensionCalib { + Produces tpcex; + Service ccdb; + ctpRateFetcher fetcher; + + Preslice perColl = aod::track::collisionId; + + using BCs = soa::Join; + using Collisions = soa::Join; + using Tracks = soa::Join; + + int runNumber{0}; + int colId{-100}; + int bcId{-100}; + int trkId{-100}; + Collisions::iterator col; + BCs::iterator bc; + Tracks::iterator track; + + void process(Collisions const& collisions, BCs const& bcs, /*aod::FT0s const& ft0s,*/ Tracks const& tracks, aod::TracksQAVersion const& tracksQA) + { + col = collisions.begin(); + bc = bcs.begin(); + runNumber = bc.runNumber(); + track = tracks.begin(); + tpcex.reserve(tracksQA.size()); + for (auto& trackqa : tracksQA) { + if (!trackqa.has_track()) { + tpcex(0); + continue; + } + if (trackqa.trackId() != trkId) { + track.setCursor(trackqa.trackId()); + } + if (!track.has_collision()) { + tpcex(0); + continue; + } + if (track.collisionId() != colId) { + colId = track.collisionId(); + col.setCursor(colId); + } + if (!col.has_foundBC()) { + tpcex(0); + continue; + } + if (col.foundBCId() != bcId) { + bc.setCursor(col.foundBCId()); + if (bc.runNumber() != runNumber) { + runNumber = bc.runNumber(); + } + } + + float rate = fetcher.fetch(ccdb.service, bc.timestamp(), runNumber, "ZNC hadronic") * 1.e-3; + float occ = col.trackOccupancyInTimeRange(); + float fOccTPCN = clamp(col.multTPC() / 1100.f, 0.f, 12.f); + + float correction0 = fReal_fTPCSignalN(clamp(50.f / track.tpcSignal(), 0.05f, 1.05f), std::abs(track.signed1Pt()), std::abs(track.tgl()), track.tgl() > 0 ? 1.f : 0.f, occ, fOccTPCN, rate / 5.f); + float correction1 = fReal_fTPCSignalN(clamp(correction0 * 50.f / track.tpcSignal(), 0.05f, 1.05f), std::abs(track.signed1Pt()), std::abs(track.tgl()), track.tgl() > 0 ? 1.f : 0.f, occ, fOccTPCN, rate / 5.); + + tpcex(track.tpcSignal() / correction1); + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return {adaptAnalysisTask(cfgc)}; +} diff --git a/Benchmarks/src/dynamic-column-func.cxx b/Benchmarks/src/produce-dynamic-extension-func.cxx similarity index 100% rename from Benchmarks/src/dynamic-column-func.cxx rename to Benchmarks/src/produce-dynamic-extension-func.cxx diff --git a/Benchmarks/src/dynamic-column.cxx b/Benchmarks/src/produce-dynamic-extension.cxx similarity index 100% rename from Benchmarks/src/dynamic-column.cxx rename to Benchmarks/src/produce-dynamic-extension.cxx diff --git a/Benchmarks/src/produce-expression-calib.cxx b/Benchmarks/src/produce-expression-calib.cxx new file mode 100644 index 00000000000..6f689a7d4d0 --- /dev/null +++ b/Benchmarks/src/produce-expression-calib.cxx @@ -0,0 +1,116 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +#include +#include "Common/CCDB/ctpRateFetcher.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "tables.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +float fReal_fTPCSignalN(float mbb0R, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.019869f * mbb0R) + (0.0012031f * a1pt) + (-0.0031766f * atgl) + (-0.0058023f * atgl * mbb0R) + (0.00087494f * a1pt * mbb0R) + (0.0020074f * side) + (-0.0010434f * a1pt * a1pt) + (0.011812f)) * occ / 1.e3f + // + ((0.009032f * mbb0R) + (0.0011737f * a1pt) + (-0.0010241f * atgl) + (-0.0075789f * atgl * mbb0R) + (0.00029324f * a1pt * mbb0R) + (0.00052475f * side) + (-0.00045413f * a1pt * a1pt) + (0.0024879f)) * fOccTPCN + // + ((0.004255f * mbb0R) + (0.0011954f * a1pt) + (0.0054092f * atgl) + (-0.0033655f * atgl * mbb0R) + (0.00052243f * a1pt * mbb0R) + (-0.0002969f * side) + (-0.00074909f * a1pt * a1pt) + (-0.0075754f)) * fTrackOccMeanN + // + ((-0.07925f * mbb0R) + (-0.03737f * a1pt) + (0.0017054f * atgl) + (0.093686f * atgl * mbb0R) + (0.023925f * a1pt * mbb0R) + (-0.0083407f * side) + (0.00336f * a1pt * a1pt) + (1.0461f)); +}; + +float clamp(float value, float lo, float hi) +{ + return value < lo ? lo : (value > hi ? hi : value); +} + +struct LeftJoin { + Produces interm; + Service ccdb; + ctpRateFetcher fetcher; + + Preslice perColl = aod::track::collisionId; + + using BCs = soa::Join; + using Collisions = soa::Join; + using Tracks = soa::Join; + + int runNumber{0}; + int colId{-100}; + int bcId{-100}; + int trkId{-100}; + Collisions::iterator col; + BCs::iterator bc; + Tracks::iterator track; + + void process(BCs const& bcs, Collisions const& collisions, Tracks const& tracks, aod::TracksQAVersion const& tracksQA) + { + interm.reserve(tracksQA.size()); + col = collisions.begin(); + bc = bcs.begin(); + runNumber = bc.runNumber(); + track = tracks.begin(); + for (auto& trackqa : tracksQA) { + if (!trackqa.has_track()) { + interm(0, 0, 0, 0, 0, o2::constants::math::Almost0, 0); + continue; + } + if (trackqa.trackId() != trkId) { + track.setCursor(trackqa.trackId()); + } + if (!track.has_collision()) { + interm(0, 0, 0, 0, 0, o2::constants::math::Almost0, 0); + continue; + } + if (track.collisionId() != colId) { + colId = track.collisionId(); + col.setCursor(colId); + } + if (!col.has_foundBC()) { + interm(0, 0, 0, 0, 0, o2::constants::math::Almost0, 0); + continue; + } + if (col.foundBCId() != bcId) { + bc.setCursor(col.foundBCId()); + if (bc.runNumber() != runNumber) { + runNumber = bc.runNumber(); + } + } + float rate = fetcher.fetch(ccdb.service, bc.timestamp(), runNumber, "ZNC hadronic") * 1.e-3; + float occ = col.trackOccupancyInTimeRange(); + float fOccTPCN = clamp(col.multTPC() / 1100.f, 0.f, 12.f); + interm(rate, fOccTPCN, occ, fReal_fTPCSignalN(clamp(50.f / track.tpcSignal(), 0.05f, 1.05f), std::abs(track.signed1Pt()), std::abs(track.tgl()), track.tgl() > 0 ? 1.f : 0.f, occ, fOccTPCN, rate / 5.f), track.tpcSignal(), track.signed1Pt(), track.tgl()); + } + } +}; + +struct ProduceExpressionCalib { + Defines tpcextra; + + void init(InitContext&) { + tpcextra.projectors[0] = ifnode(aod::track::tpcSignal < o2::constants::math::Almost0, + LiteralNode{0.f}, + aod::track::tpcSignal / ( + ((0.019869f * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.0012031f * nabs(aod::track::signed1Pt)) + (-0.0031766f * nabs(aod::track::tgl)) + (-0.0058023f * nabs(aod::track::tgl) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.00087494f * nabs(aod::track::signed1Pt) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.0020074f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0010434f * aod::track::signed1Pt * aod::track::signed1Pt) + (0.011812f)) * aod::intermediate::occupancy / 1.e3f + // + ((0.009032f * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.0011737f * nabs(aod::track::signed1Pt)) + (-0.0010241f * nabs(aod::track::tgl)) + (-0.0075789f * nabs(aod::track::tgl) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.00029324f * nabs(aod::track::signed1Pt) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.00052475f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00045413f * aod::track::signed1Pt * aod::track::signed1Pt) + (0.0024879f)) * aod::intermediate::clampedTPCmult + // + ((0.004255f * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.0011954f * nabs(aod::track::signed1Pt)) + (0.0054092f * nabs(aod::track::tgl)) + (-0.0033655f * nabs(aod::track::tgl) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.00052243f * nabs(aod::track::signed1Pt) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (-0.0002969f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00074909f * aod::track::signed1Pt * aod::track::signed1Pt) + (-0.0075754f)) * aod::intermediate::hRate / 5.f + // + ((-0.07925f * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (-0.03737f * nabs(aod::track::signed1Pt)) + (0.0017054f * nabs(aod::track::tgl)) + (0.093686f * nabs(aod::track::tgl) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.023925f * nabs(aod::track::signed1Pt) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (-0.0083407f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00336f * aod::track::signed1Pt * aod::track::signed1Pt) + (1.0461f))// + )); + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return {adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc)}; +} diff --git a/Benchmarks/src/configurable-expression-column.cxx b/Benchmarks/src/produce-expression.cxx similarity index 100% rename from Benchmarks/src/configurable-expression-column.cxx rename to Benchmarks/src/produce-expression.cxx From e8e948ff275bb251666bbf94d5abf6d11a075240 Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Wed, 28 May 2025 11:11:27 +0200 Subject: [PATCH 5/9] update copyright --- Benchmarks/CMakeLists.txt | 2 +- Benchmarks/include/tables.h | 2 +- Benchmarks/src/produce-dynamic-extension-calib.cxx | 2 +- Benchmarks/src/produce-dynamic-extension-func.cxx | 2 +- Benchmarks/src/produce-dynamic-extension.cxx | 2 +- Benchmarks/src/produce-expression-calib.cxx | 2 +- Benchmarks/src/produce-expression.cxx | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/Benchmarks/CMakeLists.txt b/Benchmarks/CMakeLists.txt index 8c142e655b3..34839d56dea 100644 --- a/Benchmarks/CMakeLists.txt +++ b/Benchmarks/CMakeLists.txt @@ -1,4 +1,4 @@ -# Copyright 2019-2020 CERN and copyright holders of ALICE O2. See +# Copyright 2019-2025 CERN and copyright holders of ALICE O2. See # https://alice-o2.web.cern.ch/copyright for details of the copyright holders. # All rights not expressly granted are reserved. # diff --git a/Benchmarks/include/tables.h b/Benchmarks/include/tables.h index bf86f71ef31..c69aeb29278 100644 --- a/Benchmarks/include/tables.h +++ b/Benchmarks/include/tables.h @@ -1,4 +1,4 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// Copyright 2019-2025 CERN and copyright holders of ALICE O2. // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. // All rights not expressly granted are reserved. // diff --git a/Benchmarks/src/produce-dynamic-extension-calib.cxx b/Benchmarks/src/produce-dynamic-extension-calib.cxx index 947d0274538..5468bf18ffb 100644 --- a/Benchmarks/src/produce-dynamic-extension-calib.cxx +++ b/Benchmarks/src/produce-dynamic-extension-calib.cxx @@ -1,4 +1,4 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// Copyright 2019-2025 CERN and copyright holders of ALICE O2. // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. // All rights not expressly granted are reserved. // diff --git a/Benchmarks/src/produce-dynamic-extension-func.cxx b/Benchmarks/src/produce-dynamic-extension-func.cxx index 5de8c3536d7..9fda7f28226 100644 --- a/Benchmarks/src/produce-dynamic-extension-func.cxx +++ b/Benchmarks/src/produce-dynamic-extension-func.cxx @@ -1,4 +1,4 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// Copyright 2019-2025 CERN and copyright holders of ALICE O2. // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. // All rights not expressly granted are reserved. // diff --git a/Benchmarks/src/produce-dynamic-extension.cxx b/Benchmarks/src/produce-dynamic-extension.cxx index f08a7f36d3e..f2b3a519fdb 100644 --- a/Benchmarks/src/produce-dynamic-extension.cxx +++ b/Benchmarks/src/produce-dynamic-extension.cxx @@ -1,4 +1,4 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// Copyright 2019-2025 CERN and copyright holders of ALICE O2. // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. // All rights not expressly granted are reserved. // diff --git a/Benchmarks/src/produce-expression-calib.cxx b/Benchmarks/src/produce-expression-calib.cxx index 6f689a7d4d0..033dd29bcf6 100644 --- a/Benchmarks/src/produce-expression-calib.cxx +++ b/Benchmarks/src/produce-expression-calib.cxx @@ -1,4 +1,4 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// Copyright 2019-2025 CERN and copyright holders of ALICE O2. // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. // All rights not expressly granted are reserved. // diff --git a/Benchmarks/src/produce-expression.cxx b/Benchmarks/src/produce-expression.cxx index 9e062758c47..612b6929d75 100644 --- a/Benchmarks/src/produce-expression.cxx +++ b/Benchmarks/src/produce-expression.cxx @@ -1,4 +1,4 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// Copyright 2019-2025 CERN and copyright holders of ALICE O2. // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. // All rights not expressly granted are reserved. // From bf3faeecd0298f70b4a99454eff4681d0fda1afd Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Wed, 28 May 2025 11:35:41 +0200 Subject: [PATCH 6/9] rename tables --- Benchmarks/include/tables.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Benchmarks/include/tables.h b/Benchmarks/include/tables.h index c69aeb29278..93dcc308923 100644 --- a/Benchmarks/include/tables.h +++ b/Benchmarks/include/tables.h @@ -60,11 +60,11 @@ DECLARE_SOA_TABLE(TracksTemporaryExtra, "AOD", "TRKTEMPEX", using TracksQAEx = soa::Join; // final table -DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(TracksQACorrectedE, TracksQAEx, "TRKWTPCE", extensions::RealTPCSignalN); +DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(TracksQACorrectedE, TracksQAEx, "TRKQACORE", extensions::RealTPCSignalN); using MoreTracksFinal = soa::Join; // final table for direct calculation -DECLARE_SOA_TABLE(TracksQACorrected, "AOD", "TPCEXT", extensions::RealTPCSignalNC); +DECLARE_SOA_TABLE(TracksQACorrected, "AOD", "TRKQACOR", extensions::RealTPCSignalNC); using TracksD = soa::Join; using TracksID = soa::Join; From 82b856877a5aee6789219fe222f214b146b215e5 Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Wed, 4 Jun 2025 11:05:15 +0200 Subject: [PATCH 7/9] Implementation of example functions --- Benchmarks/include/tables.h | 77 +++++- .../src/produce-dynamic-extension-calib.cxx | 227 +++++++++++++++++- Benchmarks/src/produce-expression-calib.cxx | 156 +++++++++++- 3 files changed, 440 insertions(+), 20 deletions(-) diff --git a/Benchmarks/include/tables.h b/Benchmarks/include/tables.h index 93dcc308923..b83703622b5 100644 --- a/Benchmarks/include/tables.h +++ b/Benchmarks/include/tables.h @@ -32,6 +32,61 @@ DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(Expr, expr, float, "Expr"); // 4. example realistic values - corrected dE/dx DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealTPCSignalN, realTPCSignalN, float, "fRealTPCSignalN"); DECLARE_SOA_COLUMN(RealTPCSignalNC, realTPCSignalNC, float); + +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMax0R0, realQMax0R0, float, "fRealQMax0R0"); +DECLARE_SOA_COLUMN(RealQMax0R0C, realQMax0R0C, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMax1R0, realQMax1R0, float, "fRealQMax1R0"); +DECLARE_SOA_COLUMN(RealQMax1R0C, realQMax1R0C, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMax2R0, realQMax2R0, float, "fRealQMax2R0"); +DECLARE_SOA_COLUMN(RealQMax2R0C, realQMax2R0C, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMax3R0, realQMax3R0, float, "fRealQMax3R0"); +DECLARE_SOA_COLUMN(RealQMax3R0C, realQMax3R0C, float); + +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQTot0R0, realQTot0R0, float, "fRealQTot0R0"); +DECLARE_SOA_COLUMN(RealQTot0R0C, realQTot0R0C, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQTot1R0, realQTot1R0, float, "fRealQTot1R0"); +DECLARE_SOA_COLUMN(RealQTot1R0C, realQTot1R0C, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQTot2R0, realQTot2R0, float, "fRealQTot2R0"); +DECLARE_SOA_COLUMN(RealQTot2R0C, realQTot2R0C, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQTot3R0, realQTot3R0, float, "fRealQTot3R0"); +DECLARE_SOA_COLUMN(RealQTot3R0C, realQTot3R0C, float); + +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMaxTot0, realQMaxTot0, float, "fRealQMaxTot0"); +DECLARE_SOA_COLUMN(RealQMaxTot0C, realQMaxTot0C, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMaxTot1, realQMaxTot1, float, "fRealQMaxTot1"); +DECLARE_SOA_COLUMN(RealQMaxTot1C, realQMaxTot1C, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMaxTot2, realQMaxTot2, float, "fRealQMaxTot2"); +DECLARE_SOA_COLUMN(RealQMaxTot2C, realQMaxTot2C, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMaxTot3, realQMaxTot3, float, "fRealQMaxTot3"); +DECLARE_SOA_COLUMN(RealQMaxTot3C, realQMaxTot3C, float); + +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMax0R0_mad, realQMax0R0_mad, float, "fRealQMax0R0_mad"); +DECLARE_SOA_COLUMN(RealQMax0R0C_mad, realQMax0R0C_mad, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMax1R0_mad, realQMax1R0_mad, float, "fRealQMax1R0_mad"); +DECLARE_SOA_COLUMN(RealQMax1R0C_mad, realQMax1R0C_mad, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMax2R0_mad, realQMax2R0_mad, float, "fRealQMax2R0_mad"); +DECLARE_SOA_COLUMN(RealQMax2R0C_mad, realQMax2R0C_mad, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMax3R0_mad, realQMax3R0_mad, float, "fRealQMax3R0_mad"); +DECLARE_SOA_COLUMN(RealQMax3R0C_mad, realQMax3R0C_mad, float); + +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQTot0R0_mad, realQTot0R0_mad, float, "fRealQTot0R0_mad"); +DECLARE_SOA_COLUMN(RealQTot0R0C_mad, realQTot0R0C_mad, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQTot1R0_mad, realQTot1R0_mad, float, "fRealQTot1R0_mad"); +DECLARE_SOA_COLUMN(RealQTot1R0C_mad, realQTot1R0C_mad, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQTot2R0_mad, realQTot2R0_mad, float, "fRealQTot2R0_mad"); +DECLARE_SOA_COLUMN(RealQTot2R0C_mad, realQTot2R0C_mad, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQTot3R0_mad, realQTot3R0_mad, float, "fRealQTot3R0_mad"); +DECLARE_SOA_COLUMN(RealQTot3R0C_mad, realQTot3R0C_mad, float); + +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMaxTot0_mad, realQMaxTot0_mad, float, "fRealQMaxTot0_mad"); +DECLARE_SOA_COLUMN(RealQMaxTot0C_mad, realQMaxTot0C_mad, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMaxTot1_mad, realQMaxTot1_mad, float, "fRealQMaxTot1_mad"); +DECLARE_SOA_COLUMN(RealQMaxTot1C_mad, realQMaxTot1C_mad, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMaxTot2_mad, realQMaxTot2_mad, float, "fRealQMaxTot2_mad"); +DECLARE_SOA_COLUMN(RealQMaxTot2C_mad, realQMaxTot2C_mad, float); +DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(RealQMaxTot3_mad, realQMaxTot3_mad, float, "fRealQMaxTot3_mad"); +DECLARE_SOA_COLUMN(RealQMaxTot3C_mad, realQMaxTot3C_mad, float); + } // namespace extensions // tables with simple and arbitrary function dynamic columns @@ -50,12 +105,12 @@ namespace intermediate { DECLARE_SOA_COLUMN(HRate, hRate, float); DECLARE_SOA_COLUMN(ClampedTPCMult, clampedTPCmult, float); DECLARE_SOA_COLUMN(Occupancy, occupancy, float); -DECLARE_SOA_COLUMN(Correction0, correction0, float); +DECLARE_SOA_COLUMN(Correction1, correction1, float); } // intermediate table DECLARE_SOA_TABLE(TracksTemporaryExtra, "AOD", "TRKTEMPEX", - intermediate::HRate, intermediate::ClampedTPCMult, intermediate::Occupancy, intermediate::Correction0, + intermediate::HRate, intermediate::ClampedTPCMult, intermediate::Occupancy, intermediate::Correction1, aod::track::TPCSignal, aod::track::Signed1Pt, aod::track::Tgl); using TracksQAEx = soa::Join; @@ -63,8 +118,26 @@ using TracksQAEx = soa::Join; DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(TracksQACorrectedE, TracksQAEx, "TRKQACORE", extensions::RealTPCSignalN); using MoreTracksFinal = soa::Join; +DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(TracksQACorrectedEFull, TracksQAEx, "TRKQACOREF", + extensions::RealTPCSignalN, + extensions::RealQMax0R0, extensions::RealQMax1R0, extensions::RealQMax2R0, extensions::RealQMax3R0, + extensions::RealQMax0R0_mad, extensions::RealQMax1R0_mad, extensions::RealQMax2R0_mad, extensions::RealQMax3R0_mad, + extensions::RealQTot0R0, extensions::RealQTot1R0, extensions::RealQTot2R0, extensions::RealQTot3R0, + extensions::RealQTot0R0_mad, extensions::RealQTot1R0_mad, extensions::RealQTot2R0_mad, extensions::RealQTot3R0_mad, + extensions::RealQMaxTot0, extensions::RealQMaxTot1, extensions::RealQMaxTot2, extensions::RealQMaxTot3, + extensions::RealQMaxTot0_mad, extensions::RealQMaxTot1_mad, extensions::RealQMaxTot2_mad, extensions::RealQMaxTot3_mad); +using MoreTracksFinalFull = soa::Join; + // final table for direct calculation DECLARE_SOA_TABLE(TracksQACorrected, "AOD", "TRKQACOR", extensions::RealTPCSignalNC); +DECLARE_SOA_TABLE(TracksQACorrectedFull, "AOD", "TRKQACORF", + extensions::RealTPCSignalNC, + extensions::RealQMax0R0C, extensions::RealQMax1R0C, extensions::RealQMax2R0C, extensions::RealQMax3R0C, + extensions::RealQMax0R0C_mad, extensions::RealQMax1R0C_mad, extensions::RealQMax2R0C_mad, extensions::RealQMax3R0C_mad, + extensions::RealQTot0R0C, extensions::RealQTot1R0C, extensions::RealQTot2R0C, extensions::RealQTot3R0C, + extensions::RealQTot0R0C_mad, extensions::RealQTot1R0C_mad, extensions::RealQTot2R0C_mad, extensions::RealQTot3R0C_mad, + extensions::RealQMaxTot0C, extensions::RealQMaxTot1C, extensions::RealQMaxTot2C, extensions::RealQMaxTot3C, + extensions::RealQMaxTot0C_mad, extensions::RealQMaxTot1C_mad, extensions::RealQMaxTot2C_mad, extensions::RealQMaxTot3C_mad); using TracksD = soa::Join; using TracksID = soa::Join; diff --git a/Benchmarks/src/produce-dynamic-extension-calib.cxx b/Benchmarks/src/produce-dynamic-extension-calib.cxx index 5468bf18ffb..2e41fc64464 100644 --- a/Benchmarks/src/produce-dynamic-extension-calib.cxx +++ b/Benchmarks/src/produce-dynamic-extension-calib.cxx @@ -31,13 +31,213 @@ float fReal_fTPCSignalN(float mbb0R, float a1pt, float atgl, float side, float o ((-0.07925f * mbb0R) + (-0.03737f * a1pt) + (0.0017054f * atgl) + (0.093686f * atgl * mbb0R) + (0.023925f * a1pt * mbb0R) + (-0.0083407f * side) + (0.00336f * a1pt * a1pt) + (1.0461f)); }; +float fReal_qMax0_R0(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.036419f * mbb0R1) + (0.0026895f * a1pt) + (-0.0060575f * atgl) + (0.0014132f * atgl * mbb0R1) + (-0.0019824f * a1pt * mbb0R1) + (0.0027807f * side) + (-0.00035062f * a1pt * a1pt) + (0.00035707f)) * occ / 1.e3f // + + ((0.018872f * mbb0R1) + (0.0025347f * a1pt) + (0.00042624f * atgl) + (-0.009566f * atgl * mbb0R1) + (-0.0013989f * a1pt * mbb0R1) + (0.00046257f * side) + (-0.00035991f * a1pt * a1pt) + (-0.0035327f)) * fOccTPCN // + + ((-0.0013489f * mbb0R1) + (-0.0012116f * a1pt) + (0.00095043f * atgl) + (0.0012604f * atgl * mbb0R1) + (0.0010987f * a1pt * mbb0R1) + (-0.0015823f * side) + (-2.0682e-05f * a1pt * a1pt) + (-0.0034631f)) * fTrackOccMeanN // + + ((0.14845f * mbb0R1) + (-0.059922f * a1pt) + (0.088597f * atgl) + (-0.046773f * atgl * mbb0R1) + (0.047535f * a1pt * mbb0R1) + (-0.0023642f * side) + (0.0041058f * a1pt * a1pt) + (0.81337f)); +}; + +float fReal_qTot0_R0(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.05379f * mbb0R1) + (0.0078357f * a1pt) + (-0.0045679f * atgl) + (-0.0055742f * atgl * mbb0R1) + (-0.0045914f * a1pt * mbb0R1) + (0.0034146f * side) + (-0.001886f * a1pt * a1pt) + (0.0015936f)) * occ / 1.e3f // + + ((0.019984f * mbb0R1) + (0.00074509f * a1pt) + (-0.0014629f * atgl) + (-0.014526f * atgl * mbb0R1) + (-0.00027911f * a1pt * mbb0R1) + (0.00076815f * side) + (-0.00027441f * a1pt * a1pt) + (0.003094f)) * fOccTPCN // + + ((0.0074452f * mbb0R1) + (-0.0012576f * a1pt) + (0.0076864f * atgl) + (-0.0057527f * atgl * mbb0R1) + (0.0010178f * a1pt * mbb0R1) + (-0.00060637f * side) + (-0.00021891f * a1pt * a1pt) + (-0.0079396f)) * fTrackOccMeanN // + + ((-0.14994f * mbb0R1) + (-0.025556f * a1pt) + (-0.0027218f * atgl) + (0.094753f * atgl * mbb0R1) + (0.024869f * a1pt * mbb0R1) + (-0.0059085f * side) + (-0.00031196f * a1pt * a1pt) + (1.0614f)); +}; + +float fReal_qMaxTot0(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((-0.011295f * mbb0R1) + (-0.001087f * a1pt) + (-0.0031759f * atgl) + (0.007727f * atgl * mbb0R1) + (-6.3106e-06f * a1pt * mbb0R1) + (-0.00051982f * side) + (0.00053087f * a1pt * a1pt) + (-0.00089624f)) * occ / 1.e3f // + + ((-0.0011264f * mbb0R1) + (0.0015426f * a1pt) + (0.0018148f * atgl) + (0.0034001f * atgl * mbb0R1) + (-0.0014034f * a1pt * mbb0R1) + (-0.00026979f * side) + (-0.00017022f * a1pt * a1pt) + (-0.0042007f)) * fOccTPCN // + + ((-0.0052403f * mbb0R1) + (-0.0014282f * a1pt) + (-0.0029884f * atgl) + (0.0036363f * atgl * mbb0R1) + (0.00052755f * a1pt * mbb0R1) + (-0.0011482f * side) + (0.00036221f * a1pt * a1pt) + (0.0021188f)) * fTrackOccMeanN // + + ((0.29443f * mbb0R1) + (-0.016326f * a1pt) + (0.084094f * atgl) + (-0.13113f * atgl * mbb0R1) + (0.021916f * a1pt * mbb0R1) + (0.0053678f * side) + (0.00047673f * a1pt * a1pt) + (0.73264f)); +}; + +float fReal_qMax1_R0(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.021162f * mbb0R1) + (0.0047311f * a1pt) + (-0.0050134f * atgl) + (-0.0020799f * atgl * mbb0R1) + (-0.0021859f * a1pt * mbb0R1) + (0.0013058f * side) + (-0.00097268f * a1pt * a1pt) + (-0.00027099f)) * occ / 1.e3f // + + ((0.010442f * mbb0R1) + (0.0032625f * a1pt) + (0.00035052f * atgl) + (-0.0061975f * atgl * mbb0R1) + (-0.00095599f * a1pt * mbb0R1) + (0.00028564f * side) + (-0.00060877f * a1pt * a1pt) + (-0.0034378f)) * fOccTPCN // + + ((0.00072113f * mbb0R1) + (0.0012692f * a1pt) + (0.0019225f * atgl) + (-4.9502e-05f * atgl * mbb0R1) + (0.0002153f * a1pt * mbb0R1) + (-0.00078837f * side) + (-0.00062101f * a1pt * a1pt) + (-0.0054873f)) * fTrackOccMeanN // + + ((0.057368f * mbb0R1) + (-0.078491f * a1pt) + (0.030685f * atgl) + (-0.026226f * atgl * mbb0R1) + (0.053421f * a1pt * mbb0R1) + (-0.0068194f * side) + (0.012138f * a1pt * a1pt) + (0.93283f)); +}; + +float fReal_qTot1_R0(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.022051f * mbb0R1) + (0.0054705f * a1pt) + (-0.0027645f * atgl) + (-0.0080202f * atgl * mbb0R1) + (-0.0010462f * a1pt * mbb0R1) + (0.0019932f * side) + (-0.0021057f * a1pt * a1pt) + (0.0095212f)) * occ / 1.e3f // + + ((0.0091488f * mbb0R1) + (0.0033904f * a1pt) + (-0.0012161f * atgl) + (-0.0071031f * atgl * mbb0R1) + (-0.00043533f * a1pt * mbb0R1) + (0.00059263f * side) + (-0.00097877f * a1pt * a1pt) + (0.00075281f)) * fOccTPCN // + + ((0.0065562f * mbb0R1) + (0.0035568f * a1pt) + (0.0055333f * atgl) + (-0.0034575f * atgl * mbb0R1) + (-0.00084672f * a1pt * mbb0R1) + (-0.00021743f * side) + (-0.0011436f * a1pt * a1pt) + (-0.010477f)) * fTrackOccMeanN // + + ((-0.076084f * mbb0R1) + (-0.047299f * a1pt) + (-0.0033743f * atgl) + (0.078502f * atgl * mbb0R1) + (0.029237f * a1pt * mbb0R1) + (-0.011353f * side) + (0.0062695f * a1pt * a1pt) + (1.0308f)); +}; + +float fReal_qMaxTot1(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.0011394f * mbb0R1) + (0.0028785f * a1pt) + (-0.0026975f * atgl) + (0.0068239f * atgl * mbb0R1) + (-0.0032394f * a1pt * mbb0R1) + (-0.00024361f * side) + (0.0001246f * a1pt * a1pt) + (-0.010253f)) * occ / 1.e3f // + + ((0.00055046f * mbb0R1) + (-0.00051361f * a1pt) + (0.0015337f * atgl) + (0.001474f * atgl * mbb0R1) + (-0.00059542f * a1pt * mbb0R1) + (-0.00033977f * side) + (0.00042607f * a1pt * a1pt) + (-0.0031188f)) * fOccTPCN // + + ((-0.004931f * mbb0R1) + (-0.0036774f * a1pt) + (-0.0017014f * atgl) + (0.0023117f * atgl * mbb0R1) + (0.0018169f * a1pt * mbb0R1) + (-0.00049096f * side) + (0.0008295f * a1pt * a1pt) + (0.0040567f)) * fTrackOccMeanN // + + ((0.15081f * mbb0R1) + (-0.016878f * a1pt) + (0.029106f * atgl) + (-0.10469f * atgl * mbb0R1) + (0.017923f * a1pt * mbb0R1) + (0.003732f * side) + (0.0033021f * a1pt * a1pt) + (0.87985f)); +}; + +float fReal_qMax2_R0(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.011954f * mbb0R1) + (0.0046224f * a1pt) + (-0.0051857f * atgl) + (-0.00081821f * atgl * mbb0R1) + (-0.0023337f * a1pt * mbb0R1) + (0.0013618f * side) + (-0.00093544f * a1pt * a1pt) + (-6.2866e-05f)) * occ / 1.e3f // + + ((0.0072282f * mbb0R1) + (0.0028697f * a1pt) + (0.00079917f * atgl) + (-0.0042087f * atgl * mbb0R1) + (-0.0015179f * a1pt * mbb0R1) + (-2.2e-05f * side) + (-0.0004591f * a1pt * a1pt) + (-0.0032937f)) * fOccTPCN // + + ((0.0011864f * mbb0R1) + (0.0017477f * a1pt) + (0.0019628f * atgl) + (-0.00099482f * atgl * mbb0R1) + (3.9852e-05f * a1pt * mbb0R1) + (-0.0006403f * side) + (-0.00070453f * a1pt * a1pt) + (-0.0045286f)) * fTrackOccMeanN // + + ((0.019613f * mbb0R1) + (-0.12656f * a1pt) + (0.019093f * atgl) + (-0.035163f * atgl * mbb0R1) + (0.081274f * a1pt * mbb0R1) + (-0.0038576f * side) + (0.026742f * a1pt * a1pt) + (0.97812f)); +}; + +float fReal_qTot2_R0(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.013053f * mbb0R1) + (0.0052803f * a1pt) + (-0.002833f * atgl) + (-0.0067229f * atgl * mbb0R1) + (-0.0015083f * a1pt * mbb0R1) + (0.0014132f * side) + (-0.0017529f * a1pt * a1pt) + (0.0045371f)) * occ / 1.e3f // + + ((0.0046757f * mbb0R1) + (0.0019132f * a1pt) + (-0.00092483f * atgl) + (-0.0040224f * atgl * mbb0R1) + (-0.00017565f * a1pt * mbb0R1) + (0.00014709f * side) + (-0.00054281f * a1pt * a1pt) + (0.00059496f)) * fOccTPCN // + + ((0.0024731f * mbb0R1) + (0.0012129f * a1pt) + (0.0041885f * atgl) + (-0.0030637f * atgl * mbb0R1) + (0.00053027f * a1pt * mbb0R1) + (-0.00064605f * side) + (-0.00073676f * a1pt * a1pt) + (-0.0048447f)) * fTrackOccMeanN // + + ((-0.03766f * mbb0R1) + (-0.017712f * a1pt) + (-0.0048423f * atgl) + (0.094793f * atgl * mbb0R1) + (0.016855f * a1pt * mbb0R1) + (-0.0063542f * side) + (0.00066842f * a1pt * a1pt) + (0.9918f)); +}; + +float fReal_qMaxTot2(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.0038681f * mbb0R1) + (0.0054964f * a1pt) + (-0.0011662f * atgl) + (0.004913f * atgl * mbb0R1) + (-0.0037561f * a1pt * mbb0R1) + (-1.4101e-05f * side) + (-0.00061975f * a1pt * a1pt) + (-0.010448f)) * occ / 1.e3f // + + ((0.0019623f * mbb0R1) + (0.00028139f * a1pt) + (0.0021717f * atgl) + (-0.00046209f * atgl * mbb0R1) + (-0.0010646f * a1pt * mbb0R1) + (-0.00023386f * side) + (0.00022279f * a1pt * a1pt) + (-0.0031211f)) * fOccTPCN // + + ((-0.001751f * mbb0R1) + (-0.0019385f * a1pt) + (-0.0013717f * atgl) + (0.0012036f * atgl * mbb0R1) + (0.00056936f * a1pt * mbb0R1) + (-3.1006e-06f * side) + (0.00060137f * a1pt * a1pt) + (0.0014547f)) * fTrackOccMeanN // + + ((0.088494f * mbb0R1) + (-0.078423f * a1pt) + (0.011554f * atgl) + (-0.1185f * atgl * mbb0R1) + (0.0446f * a1pt * mbb0R1) + (9.0607e-05f * side) + (0.020254f * a1pt * a1pt) + (0.95417f)); +}; + +float fReal_qMax3_R0(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.006657f * mbb0R1) + (0.0027675f * a1pt) + (-0.0075368f * atgl) + (-2.647e-05f * atgl * mbb0R1) + (-0.00045219f * a1pt * mbb0R1) + (0.00022622f * side) + (-0.00059026f * a1pt * a1pt) + (0.002745f)) * occ / 1.e3f // + + ((0.0072501f * mbb0R1) + (0.0028788f * a1pt) + (0.0018944f * atgl) + (-0.0050865f * atgl * mbb0R1) + (-0.0012857f * a1pt * mbb0R1) + (-1.9644e-05f * side) + (-0.00039888f * a1pt * a1pt) + (-0.004457f)) * fOccTPCN // + + ((0.0093193f * mbb0R1) + (0.01292f * a1pt) + (-0.001179f * atgl) + (0.0034663f * atgl * mbb0R1) + (-0.005494f * a1pt * mbb0R1) + (-0.00023943f * side) + (-0.0031454f * a1pt * a1pt) + (-0.015039f)) * fTrackOccMeanN // + + ((0.031517f * mbb0R1) + (-0.12968f * a1pt) + (0.013073f * atgl) + (-0.013104f * atgl * mbb0R1) + (0.064576f * a1pt * mbb0R1) + (0.0037192f * side) + (0.035161f * a1pt * a1pt) + (0.94643f)); +}; + +float fReal_qTot3_R0(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.01012f * mbb0R1) + (0.0045905f * a1pt) + (-0.0060295f * atgl) + (-0.0045184f * atgl * mbb0R1) + (-0.0011767f * a1pt * mbb0R1) + (0.00018135f * side) + (-0.0013776f * a1pt * a1pt) + (0.0030707f)) * occ / 1.e3f // + + ((0.0034954f * mbb0R1) + (0.0005948f * a1pt) + (-0.0006857f * atgl) + (-0.0032487f * atgl * mbb0R1) + (0.00063149f * a1pt * mbb0R1) + (0.00010616f * side) + (-0.00014182f * a1pt * a1pt) + (0.00016516f)) * fOccTPCN // + + ((0.012009f * mbb0R1) + (0.01333f * a1pt) + (0.0026538f * atgl) + (-0.0024246f * atgl * mbb0R1) + (-0.0051234f * a1pt * mbb0R1) + (9.6145e-05f * side) + (-0.0033937f * a1pt * a1pt) + (-0.016958f)) * fTrackOccMeanN // + + ((-0.055659f * mbb0R1) + (0.0060279f * a1pt) + (-0.024762f * atgl) + (0.1707f * atgl * mbb0R1) + (0.010545f * a1pt * mbb0R1) + (0.0053018f * side) + (-0.00751f * a1pt * a1pt) + (0.96645f)); +}; + +float fReal_qMaxTot3(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((9.8263e-05f * mbb0R1) + (0.0019565f * a1pt) + (-0.0020669f * atgl) + (0.0051386f * atgl * mbb0R1) + (-0.0015196f * a1pt * mbb0R1) + (0.00022648f * side) + (0.0001314f * a1pt * a1pt) + (-0.0044507f)) * occ / 1.e3f // + + ((0.0039512f * mbb0R1) + (0.0027043f * a1pt) + (0.0027183f * atgl) + (-0.0021564f * atgl * mbb0R1) + (-0.0019754f * a1pt * mbb0R1) + (-9.8236e-05f * side) + (-0.0003849f * a1pt * a1pt) + (-0.0048656f)) * fOccTPCN // + + ((0.0015951f * mbb0R1) + (0.0030524f * a1pt) + (-0.0021155f * atgl) + (0.004186f * atgl * mbb0R1) + (-0.0020921f * a1pt * mbb0R1) + (-0.00049161f * side) + (-0.00043331f * a1pt * a1pt) + (-0.0032405f)) * fTrackOccMeanN // + + ((0.078899f * mbb0R1) + (-0.14603f * a1pt) + (0.034436f * atgl) + (-0.17042f * atgl * mbb0R1) + (0.05807f * a1pt * mbb0R1) + (-0.00053445f * side) + (0.045416f * a1pt * a1pt) + (0.98711f)); +}; + +float fReal_fTPCSignalN_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.0022684f * mbb0R1) + (0.0010606f * a1pt) + (-6.7709e-06f * atgl) + (-0.0012901f * atgl * mbb0R1) + (1.809e-05f * a1pt * mbb0R1) + (7.4229e-05f * side) + (-0.00031708f * a1pt * a1pt) + (8.2362e-05f)) * occ / 1.e3f // + + ((-0.00015603f * mbb0R1) + (-0.0007137f * a1pt) + (-0.00029446f * atgl) + (-3.6583e-05f * atgl * mbb0R1) + (0.00065671f * a1pt * mbb0R1) + (0.00013936f * side) + (0.00012159f * a1pt * a1pt) + (0.0011442f)) * fOccTPCN // + + ((-0.00024348f * mbb0R1) + (-0.00082385f * a1pt) + (0.00053475f * atgl) + (-0.00024263f * atgl * mbb0R1) + (0.00033506f * a1pt * mbb0R1) + (1.009e-05f * side) + (0.00016525f * a1pt * a1pt) + (0.00071934f)) * fTrackOccMeanN // + + ((0.026912f * mbb0R1) + (-0.0022536f * a1pt) + (-0.0018352f * atgl) + (-0.0050977f * atgl * mbb0R1) + (-0.0041775f * a1pt * mbb0R1) + (0.0010817f * side) + (0.00032f * a1pt * a1pt) + (0.042308f)); +}; + +float fReal_qMax0_R0_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.0032739f * mbb0R1) + (-0.00083832f * a1pt) + (-0.0013899f * atgl) + (0.00031148f * atgl * mbb0R1) + (3.3722e-05f * a1pt * mbb0R1) + (0.00035792f * side) + (0.00022816f * a1pt * a1pt) + (0.0020259f)) * occ / 1.e3f // + + ((0.0011825f * mbb0R1) + (-0.00087854f * a1pt) + (-0.00060302f * atgl) + (-8.301e-06f * atgl * mbb0R1) + (0.000603f * a1pt * mbb0R1) + (0.00014523f * side) + (0.00021131f * a1pt * a1pt) + (0.00089158f)) * fOccTPCN // + + ((-0.00039752f * mbb0R1) + (-0.00067871f * a1pt) + (-0.00042804f * atgl) + (0.0003994f * atgl * mbb0R1) + (0.0003911f * a1pt * mbb0R1) + (7.6255e-05f * side) + (0.00019167f * a1pt * a1pt) + (0.00064082f)) * fTrackOccMeanN // + + ((0.05757f * mbb0R1) + (-0.00010976f * a1pt) + (-0.0053188f * atgl) + (-0.010717f * atgl * mbb0R1) + (-0.0075574f * a1pt * mbb0R1) + (0.003877f * side) + (0.00013875f * a1pt * a1pt) + (0.049855f)); +}; + +float fReal_qTot0_R0_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.010376f * mbb0R1) + (0.0020723f * a1pt) + (0.00023197f * atgl) + (-0.003087f * atgl * mbb0R1) + (-0.0014009f * a1pt * mbb0R1) + (0.00062246f * side) + (-0.00057047f * a1pt * a1pt) + (-0.00074635f)) * occ / 1.e3f // + + ((0.0039974f * mbb0R1) + (-5.2525e-05f * a1pt) + (-0.00054452f * atgl) + (-0.0017733f * atgl * mbb0R1) + (0.00038107f * a1pt * mbb0R1) + (0.00018845f * side) + (4.6742e-05f * a1pt * a1pt) + (4.6125e-05f)) * fOccTPCN // + + ((0.0011989f * mbb0R1) + (1.3873e-05f * a1pt) + (0.0001106f * atgl) + (-0.00039192f * atgl * mbb0R1) + (-0.00012419f * a1pt * mbb0R1) + (-4.8745e-05f * side) + (2.8361e-05f * a1pt * a1pt) + (-0.00013149f)) * fTrackOccMeanN // + + ((0.061978f * mbb0R1) + (-2.0672e-05f * a1pt) + (-0.0029687f * atgl) + (-0.020046f * atgl * mbb0R1) + (-0.0068452f * a1pt * mbb0R1) + (0.0060925f * side) + (-0.001742f * a1pt * a1pt) + (0.068078f)); +}; + +float fReal_qMaxTot0_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.00081584f * mbb0R1) + (0.00060523f * a1pt) + (-0.00077368f * atgl) + (0.00058048f * atgl * mbb0R1) + (-0.00055331f * a1pt * mbb0R1) + (9.2515e-05f * side) + (-7.2075e-05f * a1pt * a1pt) + (0.00040485f)) * occ / 1.e3f // + + ((0.00078366f * mbb0R1) + (0.00032795f * a1pt) + (-0.00035044f * atgl) + (-0.00010332f * atgl * mbb0R1) + (-0.00015074f * a1pt * mbb0R1) + (3.965e-05f * side) + (-6.6383e-05f * a1pt * a1pt) + (-0.00023799f)) * fOccTPCN // + + ((0.00046204f * mbb0R1) + (0.00046443f * a1pt) + (-2.0903e-05f * atgl) + (5.8387e-05f * atgl * mbb0R1) + (-0.00025348f * a1pt * mbb0R1) + (4.4914e-05f * side) + (-9.0766e-05f * a1pt * a1pt) + (-0.00033152f)) * fTrackOccMeanN // + + ((0.027694f * mbb0R1) + (-0.0011263f * a1pt) + (0.0032024f * atgl) + (-0.01575f * atgl * mbb0R1) + (-0.0016355f * a1pt * mbb0R1) + (0.0042554f * side) + (0.00065342f * a1pt * a1pt) + (0.024298f)); +}; + +float fReal_qMax1_R0_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.0045549f * mbb0R1) + (0.00087673f * a1pt) + (-0.0008244f * atgl) + (-0.00084722f * atgl * mbb0R1) + (-0.00076807f * a1pt * mbb0R1) + (0.00026f * side) + (-8.4332e-05f * a1pt * a1pt) + (-0.00046328f)) * occ / 1.e3f // + + ((0.00077207f * mbb0R1) + (-0.00066463f * a1pt) + (-0.00028896f * atgl) + (-0.00051748f * atgl * mbb0R1) + (0.00052313f * a1pt * mbb0R1) + (0.00020918f * side) + (0.00012531f * a1pt * a1pt) + (0.00077041f)) * fOccTPCN // + + ((-0.001964f * mbb0R1) + (-0.0018987f * a1pt) + (-0.00051532f * atgl) + (0.00090779f * atgl * mbb0R1) + (0.00092927f * a1pt * mbb0R1) + (-3.5317e-06f * side) + (0.00038901f * a1pt * a1pt) + (0.0023439f)) * fTrackOccMeanN // + + ((0.052395f * mbb0R1) + (0.0051874f * a1pt) + (-0.0046362f * atgl) + (-0.010693f * atgl * mbb0R1) + (-0.0031306f * a1pt * mbb0R1) + (-0.00029953f * side) + (-0.0014752f * a1pt * a1pt) + (0.05555f)); +}; + +float fReal_qTot1_R0_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.0051282f * mbb0R1) + (-0.00036785f * a1pt) + (-0.00018229f * atgl) + (-0.0021317f * atgl * mbb0R1) + (-3.9574e-05f * a1pt * mbb0R1) + (0.00046985f * side) + (-6.4708e-05f * a1pt * a1pt) + (0.0022778f)) * occ / 1.e3f // + + ((0.0011332f * mbb0R1) + (-0.00057264f * a1pt) + (-0.00048459f * atgl) + (-0.00053628f * atgl * mbb0R1) + (0.00054566f * a1pt * mbb0R1) + (0.00020773f * side) + (6.1131e-05f * a1pt * a1pt) + (0.0013186f)) * fOccTPCN // + + ((-0.0014294f * mbb0R1) + (-0.0016395f * a1pt) + (0.00050097f * atgl) + (0.00019716f * atgl * mbb0R1) + (0.0011792f * a1pt * mbb0R1) + (-6.9506e-05f * side) + (0.00028175f * a1pt * a1pt) + (0.0018185f)) * fTrackOccMeanN // + + ((0.049612f * mbb0R1) + (0.00022664f * a1pt) + (0.00069225f * atgl) + (-0.018209f * atgl * mbb0R1) + (0.001862f * a1pt * mbb0R1) + (-0.00013476f * side) + (-0.0017829f * a1pt * a1pt) + (0.067225f)); +}; + +float fReal_qMaxTot1_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.00030083f * mbb0R1) + (0.00032633f * a1pt) + (-0.00089213f * atgl) + (0.00050071f * atgl * mbb0R1) + (-0.00038379f * a1pt * mbb0R1) + (0.00013246f * side) + (-3.0354e-05f * a1pt * a1pt) + (0.0011596f)) * occ / 1.e3f // + + ((0.0011627f * mbb0R1) + (0.001223f * a1pt) + (-0.00011221f * atgl) + (-0.00038303f * atgl * mbb0R1) + (-0.00041462f * a1pt * mbb0R1) + (7.419e-05f * side) + (-0.00031261f * a1pt * a1pt) + (-0.00089038f)) * fOccTPCN // + + ((-0.00081109f * mbb0R1) + (-0.00065714f * a1pt) + (4.2318e-05f * atgl) + (0.00013371f * atgl * mbb0R1) + (0.00027371f * a1pt * mbb0R1) + (5.869e-05f * side) + (0.00013454f * a1pt * a1pt) + (0.0010851f)) * fTrackOccMeanN // + + ((0.022513f * mbb0R1) + (0.0001983f * a1pt) + (0.0016327f * atgl) + (-0.013841f * atgl * mbb0R1) + (-0.0020134f * a1pt * mbb0R1) + (0.00013836f * side) + (0.0010369f * a1pt * a1pt) + (0.027599f)); +}; + +float fReal_qMax2_R0_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.0028109f * mbb0R1) + (0.00154f * a1pt) + (-0.0014824f * atgl) + (0.00076005f * atgl * mbb0R1) + (-0.001141f * a1pt * mbb0R1) + (0.00019105f * side) + (-0.00022128f * a1pt * a1pt) + (-0.00068869f)) * occ / 1.e3f // + + ((0.00050553f * mbb0R1) + (-0.00021518f * a1pt) + (-0.00018194f * atgl) + (-0.00051275f * atgl * mbb0R1) + (0.00028182f * a1pt * mbb0R1) + (-8.0412e-06f * side) + (1.7056e-05f * a1pt * a1pt) + (0.00046885f)) * fOccTPCN // + + ((0.0014012f * mbb0R1) + (0.00080437f * a1pt) + (4.4211e-05f * atgl) + (-0.00021537f * atgl * mbb0R1) + (-0.00062642f * a1pt * mbb0R1) + (4.8299e-05f * side) + (-0.00012079f * a1pt * a1pt) + (-0.001307f)) * fTrackOccMeanN // + + ((0.025323f * mbb0R1) + (-0.017098f * a1pt) + (-0.0016086f * atgl) + (-0.015473f * atgl * mbb0R1) + (0.010693f * a1pt * mbb0R1) + (0.0010934f * side) + (0.0034083f * a1pt * a1pt) + (0.079031f)); +}; + +float fReal_qTot2_R0_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.00030261f * mbb0R1) + (-0.0023321f * a1pt) + (-0.00052643f * atgl) + (-0.0013095f * atgl * mbb0R1) + (0.0012352f * a1pt * mbb0R1) + (0.00021252f * side) + (0.00039201f * a1pt * a1pt) + (0.0041364f)) * occ / 1.e3f // + + ((7.5596e-05f * mbb0R1) + (-0.0009219f * a1pt) + (-0.00017619f * atgl) + (-0.0006923f * atgl * mbb0R1) + (0.00048164f * a1pt * mbb0R1) + (6.911e-05f * side) + (0.00014689f * a1pt * a1pt) + (0.0015109f)) * fOccTPCN // + + ((0.00026771f * mbb0R1) + (-7.3137e-05f * a1pt) + (0.0010327f * atgl) + (-0.0010829f * atgl * mbb0R1) + (0.00032905f * a1pt * mbb0R1) + (9.1216e-05f * side) + (-6.3908e-05f * a1pt * a1pt) + (-0.0001052f)) * fTrackOccMeanN // + + ((0.045023f * mbb0R1) + (-0.0012833f * a1pt) + (-0.0011393f * atgl) + (-0.0128f * atgl * mbb0R1) + (-0.00054145f * a1pt * mbb0R1) + (-0.00012961f * side) + (-0.00057735f * a1pt * a1pt) + (0.063766f)); +}; + +float fReal_qMaxTot2_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((-0.00055972f * mbb0R1) + (-5.4245e-05f * a1pt) + (-0.00086381f * atgl) + (0.00045553f * atgl * mbb0R1) + (-0.00011785f * a1pt * mbb0R1) + (0.00012989f * side) + (2.403e-05f * a1pt * a1pt) + (0.0015619f)) * occ / 1.e3f // + + ((0.00036557f * mbb0R1) + (0.00044828f * a1pt) + (-0.00033607f * atgl) + (7.8166e-05f * atgl * mbb0R1) + (-6.3217e-05f * a1pt * mbb0R1) + (-3.2699e-07f * side) + (-0.00011895f * a1pt * a1pt) + (-0.0001779f)) * fOccTPCN // + + ((0.00026633f * mbb0R1) + (0.00052126f * a1pt) + (-6.9848e-05f * atgl) + (0.00025286f * atgl * mbb0R1) + (-0.00033007f * a1pt * mbb0R1) + (8.4534e-05f * side) + (-0.00011899f * a1pt * a1pt) + (-0.00024994f)) * fTrackOccMeanN // + + ((0.028394f * mbb0R1) + (0.0062708f * a1pt) + (0.0097613f * atgl) + (-0.025715f * atgl * mbb0R1) + (-0.0040359f * a1pt * mbb0R1) + (-7.9959e-06f * side) + (7.2706e-05f * a1pt * a1pt) + (0.018673f)); +}; + +float fReal_qMax3_R0_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((-0.0016565f * mbb0R1) + (-0.0019009f * a1pt) + (-0.00018012f * atgl) + (-0.00050733f * atgl * mbb0R1) + (0.00084566f * a1pt * mbb0R1) + (0.00033188f * side) + (0.00034497f * a1pt * a1pt) + (0.003469f)) * occ / 1.e3f // + + ((0.0013034f * mbb0R1) + (0.001231f * a1pt) + (-0.00029108f * atgl) + (0.00046219f * atgl * mbb0R1) + (-0.00068638f * a1pt * mbb0R1) + (7.6018e-05f * side) + (-0.00027657f * a1pt * a1pt) + (-0.0010937f)) * fOccTPCN // + + ((-0.0017241f * mbb0R1) + (-0.0024624f * a1pt) + (-0.00029956f * atgl) + (0.00051832f * atgl * mbb0R1) + (0.0011205f * a1pt * mbb0R1) + (1.466e-06f * side) + (0.00064987f * a1pt * a1pt) + (0.0022073f)) * fTrackOccMeanN // + + ((0.027891f * mbb0R1) + (-0.042432f * a1pt) + (0.018144f * atgl) + (-0.036612f * atgl * mbb0R1) + (0.01245f * a1pt * mbb0R1) + (-0.00057199f * side) + (0.013407f * a1pt * a1pt) + (0.086444f)); +}; + +float fReal_qTot3_R0_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((2.4179e-05f * mbb0R1) + (-0.0022156f * a1pt) + (0.00063391f * atgl) + (-0.0025629f * atgl * mbb0R1) + (0.0012503f * a1pt * mbb0R1) + (0.00035431f * side) + (0.0003733f * a1pt * a1pt) + (0.0031568f)) * occ / 1.e3f // + + ((0.00064537f * mbb0R1) + (-0.00022771f * a1pt) + (-0.00052572f * atgl) + (-0.00013851f * atgl * mbb0R1) + (0.00017452f * a1pt * mbb0R1) + (5.8377e-05f * side) + (8.395e-05f * a1pt * a1pt) + (0.00032015f)) * fOccTPCN // + + ((-0.0019497f * mbb0R1) + (-0.0031993f * a1pt) + (0.0010855f * atgl) + (-0.00057412f * atgl * mbb0R1) + (0.0012335f * a1pt * mbb0R1) + (0.00015677f * side) + (0.00076355f * a1pt * a1pt) + (0.0028201f)) * fTrackOccMeanN // + + ((0.020865f * mbb0R1) + (-0.058609f * a1pt) + (0.022839f * atgl) + (-0.031806f * atgl * mbb0R1) + (0.016076f * a1pt * mbb0R1) + (-0.0010281f * side) + (0.016455f * a1pt * a1pt) + (0.10016f)); +}; + +float fReal_qMaxTot3_mad(float mbb0R1, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) +{ + return ((0.00031711f * mbb0R1) + (0.0010899f * a1pt) + (-0.00042976f * atgl) + (-0.00021686f * atgl * mbb0R1) + (-0.00044157f * a1pt * mbb0R1) + (6.7083e-05f * side) + (-0.00026787f * a1pt * a1pt) + (0.00018337f)) * occ / 1.e3f // + + ((-0.00049422f * mbb0R1) + (-0.00047902f * a1pt) + (-0.00030815f * atgl) + (2.2409e-05f * atgl * mbb0R1) + (0.00035703f * a1pt * mbb0R1) + (-1.1649e-05f * side) + (8.7419e-05f * a1pt * a1pt) + (0.00080965f)) * fOccTPCN // + + ((-9.4331e-05f * mbb0R1) + (-9.6348e-05f * a1pt) + (-0.00057261f * atgl) + (0.00085743f * atgl * mbb0R1) + (-0.00016598f * a1pt * mbb0R1) + (1.233e-06f * side) + (0.00010932f * a1pt * a1pt) + (0.00019994f)) * fTrackOccMeanN // + + ((0.020742f * mbb0R1) + (-0.023041f * a1pt) + (0.030993f * atgl) + (-0.046481f * atgl * mbb0R1) + (0.0041709f * a1pt * mbb0R1) + (0.00054496f * side) + (0.010326f * a1pt * a1pt) + (0.035667f)); +}; + float clamp(float value, float lo, float hi) { return value < lo ? lo : (value > hi ? hi : value); } struct ProduceDynamicExtensionCalib { - Produces tpcex; + Produces qacorf; Service ccdb; ctpRateFetcher fetcher; @@ -61,17 +261,17 @@ struct ProduceDynamicExtensionCalib { bc = bcs.begin(); runNumber = bc.runNumber(); track = tracks.begin(); - tpcex.reserve(tracksQA.size()); + qacorf.reserve(tracksQA.size()); for (auto& trackqa : tracksQA) { if (!trackqa.has_track()) { - tpcex(0); + qacorf(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); continue; } if (trackqa.trackId() != trkId) { track.setCursor(trackqa.trackId()); } if (!track.has_collision()) { - tpcex(0); + qacorf(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); continue; } if (track.collisionId() != colId) { @@ -79,7 +279,7 @@ struct ProduceDynamicExtensionCalib { col.setCursor(colId); } if (!col.has_foundBC()) { - tpcex(0); + qacorf(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); continue; } if (col.foundBCId() != bcId) { @@ -92,11 +292,22 @@ struct ProduceDynamicExtensionCalib { float rate = fetcher.fetch(ccdb.service, bc.timestamp(), runNumber, "ZNC hadronic") * 1.e-3; float occ = col.trackOccupancyInTimeRange(); float fOccTPCN = clamp(col.multTPC() / 1100.f, 0.f, 12.f); + float abs1pt = std::abs(track.signed1Pt()); + float abstgl = std::abs(track.tgl()); + float side = track.tgl() > 0 ? 1.f : 0.f; - float correction0 = fReal_fTPCSignalN(clamp(50.f / track.tpcSignal(), 0.05f, 1.05f), std::abs(track.signed1Pt()), std::abs(track.tgl()), track.tgl() > 0 ? 1.f : 0.f, occ, fOccTPCN, rate / 5.f); - float correction1 = fReal_fTPCSignalN(clamp(correction0 * 50.f / track.tpcSignal(), 0.05f, 1.05f), std::abs(track.signed1Pt()), std::abs(track.tgl()), track.tgl() > 0 ? 1.f : 0.f, occ, fOccTPCN, rate / 5.); + float correction0 = fReal_fTPCSignalN(clamp(50.f / track.tpcSignal(), 0.05f, 1.05f), abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.f); + auto mbb0R1 = clamp(correction0 * 50.f / track.tpcSignal(), 0.05f, 1.05f); + float correction1 = fReal_fTPCSignalN(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.); - tpcex(track.tpcSignal() / correction1); + qacorf( + track.tpcSignal() / correction1, + fReal_qMax0_R0(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMax1_R0(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMax2_R0(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMax3_R0(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), + fReal_qMax0_R0_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMax1_R0_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMax2_R0_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMax3_R0_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), + fReal_qTot0_R0(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qTot1_R0(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qTot2_R0(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qTot3_R0(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), + fReal_qTot0_R0_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qTot1_R0_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qTot2_R0_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qTot3_R0_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), + fReal_qMaxTot0(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMaxTot1(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMaxTot2(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMaxTot3(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), + fReal_qMaxTot0_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMaxTot1_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMaxTot2_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.), fReal_qMaxTot3_mad(mbb0R1, abs1pt, abstgl, side, occ, fOccTPCN, rate / 5.)); } } }; diff --git a/Benchmarks/src/produce-expression-calib.cxx b/Benchmarks/src/produce-expression-calib.cxx index 033dd29bcf6..6524f3211fc 100644 --- a/Benchmarks/src/produce-expression-calib.cxx +++ b/Benchmarks/src/produce-expression-calib.cxx @@ -90,23 +90,150 @@ struct LeftJoin { float rate = fetcher.fetch(ccdb.service, bc.timestamp(), runNumber, "ZNC hadronic") * 1.e-3; float occ = col.trackOccupancyInTimeRange(); float fOccTPCN = clamp(col.multTPC() / 1100.f, 0.f, 12.f); - interm(rate, fOccTPCN, occ, fReal_fTPCSignalN(clamp(50.f / track.tpcSignal(), 0.05f, 1.05f), std::abs(track.signed1Pt()), std::abs(track.tgl()), track.tgl() > 0 ? 1.f : 0.f, occ, fOccTPCN, rate / 5.f), track.tpcSignal(), track.signed1Pt(), track.tgl()); + float c0 = fReal_fTPCSignalN(clamp(50.f / track.tpcSignal(), 0.05f, 1.05f), std::abs(track.signed1Pt()), std::abs(track.tgl()), track.tgl() > 0 ? 1.f : 0.f, occ, fOccTPCN, rate / 5.f); + interm(rate, fOccTPCN, occ, clamp(c0 * 50.f / track.tpcSignal(), 0.05f, 1.05f), track.tpcSignal(), track.signed1Pt(), track.tgl()); } } }; struct ProduceExpressionCalib { - Defines tpcextra; + Defines qacor; void init(InitContext&) { - tpcextra.projectors[0] = ifnode(aod::track::tpcSignal < o2::constants::math::Almost0, - LiteralNode{0.f}, - aod::track::tpcSignal / ( - ((0.019869f * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.0012031f * nabs(aod::track::signed1Pt)) + (-0.0031766f * nabs(aod::track::tgl)) + (-0.0058023f * nabs(aod::track::tgl) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.00087494f * nabs(aod::track::signed1Pt) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.0020074f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0010434f * aod::track::signed1Pt * aod::track::signed1Pt) + (0.011812f)) * aod::intermediate::occupancy / 1.e3f + // - ((0.009032f * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.0011737f * nabs(aod::track::signed1Pt)) + (-0.0010241f * nabs(aod::track::tgl)) + (-0.0075789f * nabs(aod::track::tgl) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.00029324f * nabs(aod::track::signed1Pt) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.00052475f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00045413f * aod::track::signed1Pt * aod::track::signed1Pt) + (0.0024879f)) * aod::intermediate::clampedTPCmult + // - ((0.004255f * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.0011954f * nabs(aod::track::signed1Pt)) + (0.0054092f * nabs(aod::track::tgl)) + (-0.0033655f * nabs(aod::track::tgl) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.00052243f * nabs(aod::track::signed1Pt) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (-0.0002969f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00074909f * aod::track::signed1Pt * aod::track::signed1Pt) + (-0.0075754f)) * aod::intermediate::hRate / 5.f + // - ((-0.07925f * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (-0.03737f * nabs(aod::track::signed1Pt)) + (0.0017054f * nabs(aod::track::tgl)) + (0.093686f * nabs(aod::track::tgl) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (0.023925f * nabs(aod::track::signed1Pt) * expressions::clamp(aod::intermediate::correction0 * 50.f / protect0(aod::track::tpcSignal), 0.05f, 1.05f)) + (-0.0083407f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00336f * aod::track::signed1Pt * aod::track::signed1Pt) + (1.0461f))// - )); + // realTPCSignal + qacor.projectors[0] = ifnode(aod::track::tpcSignal < o2::constants::math::Almost0, + LiteralNode{0.f}, + aod::track::tpcSignal / (((0.019869f * aod::intermediate::correction1) + (0.0012031f * nabs(aod::track::signed1Pt)) + (-0.0031766f * nabs(aod::track::tgl)) + (-0.0058023f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00087494f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0020074f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0010434f * aod::track::signed1Pt * aod::track::signed1Pt) + (0.011812f)) * aod::intermediate::occupancy / 1.e3f + // + ((0.009032f * aod::intermediate::correction1) + (0.0011737f * nabs(aod::track::signed1Pt)) + (-0.0010241f * nabs(aod::track::tgl)) + (-0.0075789f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00029324f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00052475f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00045413f * aod::track::signed1Pt * aod::track::signed1Pt) + (0.0024879f)) * aod::intermediate::clampedTPCmult + // + ((0.004255f * aod::intermediate::correction1) + (0.0011954f * nabs(aod::track::signed1Pt)) + (0.0054092f * nabs(aod::track::tgl)) + (-0.0033655f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00052243f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.0002969f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00074909f * aod::track::signed1Pt * aod::track::signed1Pt) + (-0.0075754f)) * aod::intermediate::hRate / 5.f + // + ((-0.07925f * aod::intermediate::correction1) + (-0.03737f * nabs(aod::track::signed1Pt)) + (0.0017054f * nabs(aod::track::tgl)) + (0.093686f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.023925f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.0083407f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00336f * aod::track::signed1Pt * aod::track::signed1Pt) + (1.0461f)) // + )); + + // qMax0R0 + qacor.projectors[1] = ((0.036419f * aod::intermediate::correction1) + (0.0026895f * nabs(aod::track::signed1Pt)) + (-0.0060575f * nabs(aod::track::tgl)) + (0.0014132f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0019824f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0027807f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00035062f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00035707f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.018872f * aod::intermediate::correction1) + (0.0025347f * nabs(aod::track::signed1Pt)) + (0.00042624f * nabs(aod::track::tgl)) + (-0.009566f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0013989f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00046257f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00035991f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0035327f)) * aod::intermediate::clampedTPCmult // + + ((-0.0013489f * aod::intermediate::correction1) + (-0.0012116f * nabs(aod::track::signed1Pt)) + (0.00095043f * nabs(aod::track::tgl)) + (0.0012604f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0010987f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.0015823f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-2.0682e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0034631f)) * aod::intermediate::hRate // + + ((0.14845f * aod::intermediate::correction1) + (-0.059922f * nabs(aod::track::signed1Pt)) + (0.088597f * nabs(aod::track::tgl)) + (-0.046773f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.047535f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.0023642f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.0041058f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.81337f)); + // qMax1R0 + qacor.projectors[2] = ((0.021162f * aod::intermediate::correction1) + (0.0047311f * nabs(aod::track::signed1Pt)) + (-0.0050134f * nabs(aod::track::tgl)) + (-0.0020799f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0021859f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0013058f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00097268f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.00027099f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.010442f * aod::intermediate::correction1) + (0.0032625f * nabs(aod::track::signed1Pt)) + (0.00035052f * nabs(aod::track::tgl)) + (-0.0061975f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00095599f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00028564f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00060877f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0034378f)) * aod::intermediate::clampedTPCmult // + + ((0.00072113f * aod::intermediate::correction1) + (0.0012692f * nabs(aod::track::signed1Pt)) + (0.0019225f * nabs(aod::track::tgl)) + (-4.9502e-05f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0002153f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00078837f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00062101f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0054873f)) * aod::intermediate::hRate // + + ((0.057368f * aod::intermediate::correction1) + (-0.078491f * nabs(aod::track::signed1Pt)) + (0.030685f * nabs(aod::track::tgl)) + (-0.026226f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.053421f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.0068194f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.012138f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.93283f)); + // qMax2R0 + qacor.projectors[3] = ((0.011954f * aod::intermediate::correction1) + (0.0046224f * nabs(aod::track::signed1Pt)) + (-0.0051857f * nabs(aod::track::tgl)) + (-0.00081821f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0023337f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0013618f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00093544f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-6.2866e-05f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0072282f * aod::intermediate::correction1) + (0.0028697f * nabs(aod::track::signed1Pt)) + (0.00079917f * nabs(aod::track::tgl)) + (-0.0042087f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0015179f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-2.2e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0004591f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0032937f)) * aod::intermediate::clampedTPCmult // + + ((0.0011864f * aod::intermediate::correction1) + (0.0017477f * nabs(aod::track::signed1Pt)) + (0.0019628f * nabs(aod::track::tgl)) + (-0.00099482f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (3.9852e-05f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.0006403f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00070453f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0045286f)) * aod::intermediate::hRate // + + ((0.019613f * aod::intermediate::correction1) + (-0.12656f * nabs(aod::track::signed1Pt)) + (0.019093f * nabs(aod::track::tgl)) + (-0.035163f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.081274f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.0038576f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.026742f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.97812f)); + // qMax3R0 + qacor.projectors[4] = ((0.006657f * aod::intermediate::correction1) + (0.0027675f * nabs(aod::track::signed1Pt)) + (-0.0075368f * nabs(aod::track::tgl)) + (-2.647e-05f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00045219f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00022622f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00059026f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.002745f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0072501f * aod::intermediate::correction1) + (0.0028788f * nabs(aod::track::signed1Pt)) + (0.0018944f * nabs(aod::track::tgl)) + (-0.0050865f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0012857f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-1.9644e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00039888f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.004457f)) * aod::intermediate::clampedTPCmult // + + ((0.0093193f * aod::intermediate::correction1) + (0.01292f * nabs(aod::track::signed1Pt)) + (-0.001179f * nabs(aod::track::tgl)) + (0.0034663f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.005494f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00023943f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0031454f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.015039f)) * aod::intermediate::hRate // + + ((0.031517f * aod::intermediate::correction1) + (-0.12968f * nabs(aod::track::signed1Pt)) + (0.013073f * nabs(aod::track::tgl)) + (-0.013104f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.064576f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0037192f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.035161f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.94643f)); + + // qMax0R0_mad + qacor.projectors[5] = ((0.0032739f * aod::intermediate::correction1) + (-0.00083832f * nabs(aod::track::signed1Pt)) + (-0.0013899f * nabs(aod::track::tgl)) + (0.00031148f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (3.3722e-05f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00035792f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00022816f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0020259f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0011825f * aod::intermediate::correction1) + (-0.00087854f * nabs(aod::track::signed1Pt)) + (-0.00060302f * nabs(aod::track::tgl)) + (-8.301e-06f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.000603f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00014523f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00021131f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00089158f)) * aod::intermediate::clampedTPCmult // + + ((-0.00039752f * aod::intermediate::correction1) + (-0.00067871f * nabs(aod::track::signed1Pt)) + (-0.00042804f * nabs(aod::track::tgl)) + (0.0003994f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0003911f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (7.6255e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00019167f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00064082f)) * aod::intermediate::hRate // + + ((0.05757f * aod::intermediate::correction1) + (-0.00010976f * nabs(aod::track::signed1Pt)) + (-0.0053188f * nabs(aod::track::tgl)) + (-0.010717f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0075574f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.003877f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00013875f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.049855f)); + // qMax1R0_mad + qacor.projectors[6] = ((0.0045549f * aod::intermediate::correction1) + (0.00087673f * nabs(aod::track::signed1Pt)) + (-0.0008244f * nabs(aod::track::tgl)) + (-0.00084722f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00076807f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00026f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-8.4332e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.00046328f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.00077207f * aod::intermediate::correction1) + (-0.00066463f * nabs(aod::track::signed1Pt)) + (-0.00028896f * nabs(aod::track::tgl)) + (-0.00051748f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00052313f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00020918f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00012531f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00077041f)) * aod::intermediate::clampedTPCmult // + + ((-0.001964f * aod::intermediate::correction1) + (-0.0018987f * nabs(aod::track::signed1Pt)) + (-0.00051532f * nabs(aod::track::tgl)) + (0.00090779f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00092927f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-3.5317e-06f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00038901f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0023439f)) * aod::intermediate::hRate // + + ((0.052395f * aod::intermediate::correction1) + (0.0051874f * nabs(aod::track::signed1Pt)) + (-0.0046362f * nabs(aod::track::tgl)) + (-0.010693f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0031306f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00029953f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0014752f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.05555f)); + // qMax2R0_mad + qacor.projectors[7] = ((0.0028109f * aod::intermediate::correction1) + (0.00154f * nabs(aod::track::signed1Pt)) + (-0.0014824f * nabs(aod::track::tgl)) + (0.00076005f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.001141f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00019105f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00022128f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.00068869f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.00050553f * aod::intermediate::correction1) + (-0.00021518f * nabs(aod::track::signed1Pt)) + (-0.00018194f * nabs(aod::track::tgl)) + (-0.00051275f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00028182f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-8.0412e-06f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (1.7056e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00046885f)) * aod::intermediate::clampedTPCmult // + + ((0.0014012f * aod::intermediate::correction1) + (0.00080437f * nabs(aod::track::signed1Pt)) + (4.4211e-05f * nabs(aod::track::tgl)) + (-0.00021537f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00062642f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (4.8299e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00012079f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.001307f)) * aod::intermediate::hRate // + + ((0.025323f * aod::intermediate::correction1) + (-0.017098f * nabs(aod::track::signed1Pt)) + (-0.0016086f * nabs(aod::track::tgl)) + (-0.015473f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.010693f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0010934f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.0034083f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.079031f)); + // qMax3R0_mad + qacor.projectors[8] = ((-0.0016565f * aod::intermediate::correction1) + (-0.0019009f * nabs(aod::track::signed1Pt)) + (-0.00018012f * nabs(aod::track::tgl)) + (-0.00050733f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00084566f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00033188f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00034497f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.003469f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0013034f * aod::intermediate::correction1) + (0.001231f * nabs(aod::track::signed1Pt)) + (-0.00029108f * nabs(aod::track::tgl)) + (0.00046219f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00068638f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (7.6018e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00027657f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0010937f)) * aod::intermediate::clampedTPCmult // + + ((-0.0017241f * aod::intermediate::correction1) + (-0.0024624f * nabs(aod::track::signed1Pt)) + (-0.00029956f * nabs(aod::track::tgl)) + (0.00051832f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0011205f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (1.466e-06f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00064987f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0022073f)) * aod::intermediate::hRate // + + ((0.027891f * aod::intermediate::correction1) + (-0.042432f * nabs(aod::track::signed1Pt)) + (0.018144f * nabs(aod::track::tgl)) + (-0.036612f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.01245f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00057199f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.013407f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.086444f)); + + // qTot0R0 + qacor.projectors[9] = ((0.05379f * aod::intermediate::correction1) + (0.0078357f * nabs(aod::track::signed1Pt)) + (-0.0045679f * nabs(aod::track::tgl)) + (-0.0055742f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0045914f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0034146f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.001886f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0015936f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.019984f * aod::intermediate::correction1) + (0.00074509f * nabs(aod::track::signed1Pt)) + (-0.0014629f * nabs(aod::track::tgl)) + (-0.014526f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00027911f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00076815f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00027441f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.003094f)) * aod::intermediate::clampedTPCmult // + + ((0.0074452f * aod::intermediate::correction1) + (-0.0012576f * nabs(aod::track::signed1Pt)) + (0.0076864f * nabs(aod::track::tgl)) + (-0.0057527f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0010178f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00060637f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00021891f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0079396f)) * aod::intermediate::hRate // + + ((-0.14994f * aod::intermediate::correction1) + (-0.025556f * nabs(aod::track::signed1Pt)) + (-0.0027218f * nabs(aod::track::tgl)) + (0.094753f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.024869f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.0059085f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00031196f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (1.0614f)); + // qTot1R0 + qacor.projectors[10] = ((0.022051f * aod::intermediate::correction1) + (0.0054705f * nabs(aod::track::signed1Pt)) + (-0.0027645f * nabs(aod::track::tgl)) + (-0.0080202f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0010462f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0019932f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0021057f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0095212f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0091488f * aod::intermediate::correction1) + (0.0033904f * nabs(aod::track::signed1Pt)) + (-0.0012161f * nabs(aod::track::tgl)) + (-0.0071031f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00043533f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00059263f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00097877f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00075281f)) * aod::intermediate::clampedTPCmult // + + ((0.0065562f * aod::intermediate::correction1) + (0.0035568f * nabs(aod::track::signed1Pt)) + (0.0055333f * nabs(aod::track::tgl)) + (-0.0034575f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00084672f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00021743f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0011436f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.010477f)) * aod::intermediate::hRate // + + ((-0.076084f * aod::intermediate::correction1) + (-0.047299f * nabs(aod::track::signed1Pt)) + (-0.0033743f * nabs(aod::track::tgl)) + (0.078502f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.029237f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.011353f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.0062695f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (1.0308f)); + // qTot2R0 + qacor.projectors[11] = ((0.013053f * aod::intermediate::correction1) + (0.0052803f * nabs(aod::track::signed1Pt)) + (-0.002833f * nabs(aod::track::tgl)) + (-0.0067229f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0015083f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0014132f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0017529f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0045371f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0046757f * aod::intermediate::correction1) + (0.0019132f * nabs(aod::track::signed1Pt)) + (-0.00092483f * nabs(aod::track::tgl)) + (-0.0040224f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00017565f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00014709f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00054281f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00059496f)) * aod::intermediate::clampedTPCmult // + + ((0.0024731f * aod::intermediate::correction1) + (0.0012129f * nabs(aod::track::signed1Pt)) + (0.0041885f * nabs(aod::track::tgl)) + (-0.0030637f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00053027f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00064605f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00073676f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0048447f)) * aod::intermediate::hRate // + + ((-0.03766f * aod::intermediate::correction1) + (-0.017712f * nabs(aod::track::signed1Pt)) + (-0.0048423f * nabs(aod::track::tgl)) + (0.094793f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.016855f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.0063542f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00066842f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.9918f)); + // qTot3R0 + qacor.projectors[12] = ((0.01012f * aod::intermediate::correction1) + (0.0045905f * nabs(aod::track::signed1Pt)) + (-0.0060295f * nabs(aod::track::tgl)) + (-0.0045184f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0011767f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00018135f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0013776f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0030707f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0034954f * aod::intermediate::correction1) + (0.0005948f * nabs(aod::track::signed1Pt)) + (-0.0006857f * nabs(aod::track::tgl)) + (-0.0032487f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00063149f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00010616f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00014182f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00016516f)) * aod::intermediate::clampedTPCmult // + + ((0.012009f * aod::intermediate::correction1) + (0.01333f * nabs(aod::track::signed1Pt)) + (0.0026538f * nabs(aod::track::tgl)) + (-0.0024246f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0051234f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (9.6145e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0033937f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.016958f)) * aod::intermediate::hRate // + + ((-0.055659f * aod::intermediate::correction1) + (0.0060279f * nabs(aod::track::signed1Pt)) + (-0.024762f * nabs(aod::track::tgl)) + (0.1707f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.010545f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0053018f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00751f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.96645f)); + + // qTot0R0_mad + qacor.projectors[13] = ((0.010376f * aod::intermediate::correction1) + (0.0020723f * nabs(aod::track::signed1Pt)) + (0.00023197f * nabs(aod::track::tgl)) + (-0.003087f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0014009f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00062246f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00057047f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.00074635f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0039974f * aod::intermediate::correction1) + (-5.2525e-05f * nabs(aod::track::signed1Pt)) + (-0.00054452f * nabs(aod::track::tgl)) + (-0.0017733f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00038107f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00018845f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (4.6742e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (4.6125e-05f)) * aod::intermediate::clampedTPCmult // + + ((0.0011989f * aod::intermediate::correction1) + (1.3873e-05f * nabs(aod::track::signed1Pt)) + (0.0001106f * nabs(aod::track::tgl)) + (-0.00039192f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00012419f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-4.8745e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (2.8361e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.00013149f)) * aod::intermediate::hRate // + + ((0.061978f * aod::intermediate::correction1) + (-2.0672e-05f * nabs(aod::track::signed1Pt)) + (-0.0029687f * nabs(aod::track::tgl)) + (-0.020046f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0068452f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0060925f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.001742f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.068078f)); + // qTot1R0_mad + qacor.projectors[14] = ((0.0051282f * aod::intermediate::correction1) + (-0.00036785f * nabs(aod::track::signed1Pt)) + (-0.00018229f * nabs(aod::track::tgl)) + (-0.0021317f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-3.9574e-05f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00046985f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-6.4708e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0022778f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0011332f * aod::intermediate::correction1) + (-0.00057264f * nabs(aod::track::signed1Pt)) + (-0.00048459f * nabs(aod::track::tgl)) + (-0.00053628f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00054566f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00020773f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (6.1131e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0013186f)) * aod::intermediate::clampedTPCmult // + + ((-0.0014294f * aod::intermediate::correction1) + (-0.0016395f * nabs(aod::track::signed1Pt)) + (0.00050097f * nabs(aod::track::tgl)) + (0.00019716f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0011792f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-6.9506e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00028175f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0018185f)) * aod::intermediate::hRate // + + ((0.049612f * aod::intermediate::correction1) + (0.00022664f * nabs(aod::track::signed1Pt)) + (0.00069225f * nabs(aod::track::tgl)) + (-0.018209f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.001862f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00013476f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0017829f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.067225f)); + // qTot2R0_mad + qacor.projectors[15] = ((0.00030261f * aod::intermediate::correction1) + (-0.0023321f * nabs(aod::track::signed1Pt)) + (-0.00052643f * nabs(aod::track::tgl)) + (-0.0013095f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0012352f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00021252f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00039201f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0041364f)) * aod::intermediate::occupancy / 1.e3f // + + ((7.5596e-05f * aod::intermediate::correction1) + (-0.0009219f * nabs(aod::track::signed1Pt)) + (-0.00017619f * nabs(aod::track::tgl)) + (-0.0006923f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00048164f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (6.911e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00014689f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0015109f)) * aod::intermediate::clampedTPCmult // + + ((0.00026771f * aod::intermediate::correction1) + (-7.3137e-05f * nabs(aod::track::signed1Pt)) + (0.0010327f * nabs(aod::track::tgl)) + (-0.0010829f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00032905f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (9.1216e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-6.3908e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0001052f)) * aod::intermediate::hRate // + + ((0.045023f * aod::intermediate::correction1) + (-0.0012833f * nabs(aod::track::signed1Pt)) + (-0.0011393f * nabs(aod::track::tgl)) + (-0.0128f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00054145f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00012961f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00057735f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.063766f)); + // qTot3R0_mad + qacor.projectors[16] = ((2.4179e-05f * aod::intermediate::correction1) + (-0.0022156f * nabs(aod::track::signed1Pt)) + (0.00063391f * nabs(aod::track::tgl)) + (-0.0025629f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0012503f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00035431f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.0003733f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0031568f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.00064537f * aod::intermediate::correction1) + (-0.00022771f * nabs(aod::track::signed1Pt)) + (-0.00052572f * nabs(aod::track::tgl)) + (-0.00013851f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00017452f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (5.8377e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (8.395e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00032015f)) * aod::intermediate::clampedTPCmult // + + ((-0.0019497f * aod::intermediate::correction1) + (-0.0031993f * nabs(aod::track::signed1Pt)) + (0.0010855f * nabs(aod::track::tgl)) + (-0.00057412f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0012335f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00015677f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00076355f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0028201f)) * aod::intermediate::hRate // + + ((0.020865f * aod::intermediate::correction1) + (-0.058609f * nabs(aod::track::signed1Pt)) + (0.022839f * nabs(aod::track::tgl)) + (-0.031806f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.016076f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.0010281f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.016455f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.10016f)); + + // qMaxTot0 + qacor.projectors[17] = ((-0.011295f * aod::intermediate::correction1) + (-0.001087f * nabs(aod::track::signed1Pt)) + (-0.0031759f * nabs(aod::track::tgl)) + (0.007727f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-6.3106e-06f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00051982f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00053087f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.00089624f)) * aod::intermediate::occupancy / 1.e3f // + + ((-0.0011264f * aod::intermediate::correction1) + (0.0015426f * nabs(aod::track::signed1Pt)) + (0.0018148f * nabs(aod::track::tgl)) + (0.0034001f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0014034f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00026979f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00017022f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0042007f)) * aod::intermediate::clampedTPCmult // + + ((-0.0052403f * aod::intermediate::correction1) + (-0.0014282f * nabs(aod::track::signed1Pt)) + (-0.0029884f * nabs(aod::track::tgl)) + (0.0036363f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00052755f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.0011482f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00036221f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0021188f)) * aod::intermediate::hRate // + + ((0.29443f * aod::intermediate::correction1) + (-0.016326f * nabs(aod::track::signed1Pt)) + (0.084094f * nabs(aod::track::tgl)) + (-0.13113f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.021916f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0053678f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00047673f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.73264f)); + // qMaxTot1 + qacor.projectors[18] = ((0.0011394f * aod::intermediate::correction1) + (0.0028785f * nabs(aod::track::signed1Pt)) + (-0.0026975f * nabs(aod::track::tgl)) + (0.0068239f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0032394f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00024361f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.0001246f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.010253f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.00055046f * aod::intermediate::correction1) + (-0.00051361f * nabs(aod::track::signed1Pt)) + (0.0015337f * nabs(aod::track::tgl)) + (0.001474f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00059542f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00033977f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00042607f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0031188f)) * aod::intermediate::clampedTPCmult // + + ((-0.004931f * aod::intermediate::correction1) + (-0.0036774f * nabs(aod::track::signed1Pt)) + (-0.0017014f * nabs(aod::track::tgl)) + (0.0023117f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0018169f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00049096f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.0008295f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0040567f)) * aod::intermediate::hRate // + + ((0.15081f * aod::intermediate::correction1) + (-0.016878f * nabs(aod::track::signed1Pt)) + (0.029106f * nabs(aod::track::tgl)) + (-0.10469f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.017923f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.003732f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.0033021f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.87985f)); + // qMaxTot2 + qacor.projectors[19] = ((0.0038681f * aod::intermediate::correction1) + (0.0054964f * nabs(aod::track::signed1Pt)) + (-0.0011662f * nabs(aod::track::tgl)) + (0.004913f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0037561f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-1.4101e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00061975f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.010448f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0019623f * aod::intermediate::correction1) + (0.00028139f * nabs(aod::track::signed1Pt)) + (0.0021717f * nabs(aod::track::tgl)) + (-0.00046209f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0010646f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00023386f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00022279f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0031211f)) * aod::intermediate::clampedTPCmult // + + ((-0.001751f * aod::intermediate::correction1) + (-0.0019385f * nabs(aod::track::signed1Pt)) + (-0.0013717f * nabs(aod::track::tgl)) + (0.0012036f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00056936f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-3.1006e-06f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00060137f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0014547f)) * aod::intermediate::hRate // + + ((0.088494f * aod::intermediate::correction1) + (-0.078423f * nabs(aod::track::signed1Pt)) + (0.011554f * nabs(aod::track::tgl)) + (-0.1185f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0446f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (9.0607e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.020254f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.95417f)); + // qMaxTot3 + qacor.projectors[20] = ((9.8263e-05f * aod::intermediate::correction1) + (0.0019565f * nabs(aod::track::signed1Pt)) + (-0.0020669f * nabs(aod::track::tgl)) + (0.0051386f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0015196f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00022648f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.0001314f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0044507f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0039512f * aod::intermediate::correction1) + (0.0027043f * nabs(aod::track::signed1Pt)) + (0.0027183f * nabs(aod::track::tgl)) + (-0.0021564f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0019754f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-9.8236e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.0003849f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0048656f)) * aod::intermediate::clampedTPCmult // + + ((0.0015951f * aod::intermediate::correction1) + (0.0030524f * nabs(aod::track::signed1Pt)) + (-0.0021155f * nabs(aod::track::tgl)) + (0.004186f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0020921f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00049161f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00043331f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0032405f)) * aod::intermediate::hRate // + + ((0.078899f * aod::intermediate::correction1) + (-0.14603f * nabs(aod::track::signed1Pt)) + (0.034436f * nabs(aod::track::tgl)) + (-0.17042f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.05807f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-0.00053445f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.045416f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.98711f)); + + // qMaxTot0_mad + qacor.projectors[21] = ((0.00081584f * aod::intermediate::correction1) + (0.00060523f * nabs(aod::track::signed1Pt)) + (-0.00077368f * nabs(aod::track::tgl)) + (0.00058048f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00055331f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (9.2515e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-7.2075e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00040485f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.00078366f * aod::intermediate::correction1) + (0.00032795f * nabs(aod::track::signed1Pt)) + (-0.00035044f * nabs(aod::track::tgl)) + (-0.00010332f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00015074f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (3.965e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-6.6383e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.00023799f)) * aod::intermediate::clampedTPCmult // + + ((0.00046204f * aod::intermediate::correction1) + (0.00046443f * nabs(aod::track::signed1Pt)) + (-2.0903e-05f * nabs(aod::track::tgl)) + (5.8387e-05f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00025348f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (4.4914e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-9.0766e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.00033152f)) * aod::intermediate::hRate // + + ((0.027694f * aod::intermediate::correction1) + (-0.0011263f * nabs(aod::track::signed1Pt)) + (0.0032024f * nabs(aod::track::tgl)) + (-0.01575f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0016355f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0042554f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00065342f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.024298f)); + // qMaxTot1_mad + qacor.projectors[22] = ((0.00030083f * aod::intermediate::correction1) + (0.00032633f * nabs(aod::track::signed1Pt)) + (-0.00089213f * nabs(aod::track::tgl)) + (0.00050071f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00038379f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00013246f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-3.0354e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0011596f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.0011627f * aod::intermediate::correction1) + (0.001223f * nabs(aod::track::signed1Pt)) + (-0.00011221f * nabs(aod::track::tgl)) + (-0.00038303f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00041462f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (7.419e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00031261f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.00089038f)) * aod::intermediate::clampedTPCmult // + + ((-0.00081109f * aod::intermediate::correction1) + (-0.00065714f * nabs(aod::track::signed1Pt)) + (4.2318e-05f * nabs(aod::track::tgl)) + (0.00013371f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00027371f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (5.869e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00013454f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0010851f)) * aod::intermediate::hRate // + + ((0.022513f * aod::intermediate::correction1) + (0.0001983f * nabs(aod::track::signed1Pt)) + (0.0016327f * nabs(aod::track::tgl)) + (-0.013841f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0020134f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00013836f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.0010369f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.027599f)); + // qMaxTot2_mad + qacor.projectors[23] = ((-0.00055972f * aod::intermediate::correction1) + (-5.4245e-05f * nabs(aod::track::signed1Pt)) + (-0.00086381f * nabs(aod::track::tgl)) + (0.00045553f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00011785f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00012989f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (2.403e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0015619f)) * aod::intermediate::occupancy / 1.e3f // + + ((0.00036557f * aod::intermediate::correction1) + (0.00044828f * nabs(aod::track::signed1Pt)) + (-0.00033607f * nabs(aod::track::tgl)) + (7.8166e-05f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-6.3217e-05f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-3.2699e-07f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00011895f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.0001779f)) * aod::intermediate::clampedTPCmult // + + ((0.00026633f * aod::intermediate::correction1) + (0.00052126f * nabs(aod::track::signed1Pt)) + (-6.9848e-05f * nabs(aod::track::tgl)) + (0.00025286f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00033007f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (8.4534e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00011899f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (-0.00024994f)) * aod::intermediate::hRate // + + ((0.028394f * aod::intermediate::correction1) + (0.0062708f * nabs(aod::track::signed1Pt)) + (0.0097613f * nabs(aod::track::tgl)) + (-0.025715f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0040359f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-7.9959e-06f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (7.2706e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.018673f)); + // qMaxTot3_mad + qacor.projectors[24] = ((0.00031711f * aod::intermediate::correction1) + (0.0010899f * nabs(aod::track::signed1Pt)) + (-0.00042976f * nabs(aod::track::tgl)) + (-0.00021686f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00044157f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (6.7083e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00026787f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00018337f)) * aod::intermediate::occupancy / 1.e3f // + + ((-0.00049422f * aod::intermediate::correction1) + (-0.00047902f * nabs(aod::track::signed1Pt)) + (-0.00030815f * nabs(aod::track::tgl)) + (2.2409e-05f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00035703f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (-1.1649e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (8.7419e-05f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00080965f)) * aod::intermediate::clampedTPCmult // + + ((-9.4331e-05f * aod::intermediate::correction1) + (-9.6348e-05f * nabs(aod::track::signed1Pt)) + (-0.00057261f * nabs(aod::track::tgl)) + (0.00085743f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.00016598f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (1.233e-06f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00010932f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00019994f)) * aod::intermediate::hRate // + + ((0.020742f * aod::intermediate::correction1) + (-0.023041f * nabs(aod::track::signed1Pt)) + (0.030993f * nabs(aod::track::tgl)) + (-0.046481f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.0041709f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00054496f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.010326f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.035667f)); } }; @@ -114,3 +241,12 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return {adaptAnalysisTask(cfgc), adaptAnalysisTask(cfgc)}; } + +/* +float fReal_fTPCSignalN_mad(float aod::intermediate::correction1, float nabs(aod::track::signed1Pt), float nabs(aod::track::tgl), float ifnode(aod::track::tgl > 0.f, 1.f, 0.f), float occ, float aod::intermediate::clampedTPCmult, float aod::intermediate::hRate) { +return ((0.0022684f * aod::intermediate::correction1) + (0.0010606f * nabs(aod::track::signed1Pt)) + (-6.7709e-06f * nabs(aod::track::tgl)) + (-0.0012901f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (1.809e-05f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (7.4229e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (-0.00031708f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (8.2362e-05f)) * aod::intermediate::occupancy / 1.e3f // + + ((-0.00015603f * aod::intermediate::correction1) + (-0.0007137f * nabs(aod::track::signed1Pt)) + (-0.00029446f * nabs(aod::track::tgl)) + (-3.6583e-05f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00065671f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.00013936f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00012159f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.0011442f)) * aod::intermediate::clampedTPCmult // + + ((-0.00024348f * aod::intermediate::correction1) + (-0.00082385f * nabs(aod::track::signed1Pt)) + (0.00053475f * nabs(aod::track::tgl)) + (-0.00024263f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (0.00033506f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (1.009e-05f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00016525f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.00071934f)) * aod::intermediate::hRate // + + ((0.026912f * aod::intermediate::correction1) + (-0.0022536f * nabs(aod::track::signed1Pt)) + (-0.0018352f * nabs(aod::track::tgl)) + (-0.0050977f * nabs(aod::track::tgl) * aod::intermediate::correction1) + (-0.0041775f * nabs(aod::track::signed1Pt) * aod::intermediate::correction1) + (0.0010817f * ifnode(aod::track::tgl > 0.f, 1.f, 0.f)) + (0.00032f * nabs(aod::track::signed1Pt) * nabs(aod::track::signed1Pt)) + (0.042308f)); +}; +*/ From f2580f623c7a2e25b803986dcdbd5e66b443d97f Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 4 Jun 2025 09:06:00 +0000 Subject: [PATCH 8/9] Please consider the following formatting changes --- Benchmarks/include/tables.h | 5 +++-- Benchmarks/src/produce-dynamic-extension-calib.cxx | 5 ++--- Benchmarks/src/produce-expression-calib.cxx | 7 ++++--- 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/Benchmarks/include/tables.h b/Benchmarks/include/tables.h index b83703622b5..42089fb2b4f 100644 --- a/Benchmarks/include/tables.h +++ b/Benchmarks/include/tables.h @@ -101,12 +101,13 @@ DECLARE_SOA_TABLE(ExtTracksIDM, "AOD", "TRKIDM", extensions::IndirectM); DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(TracksE, TracksIU, "TRKE", extensions::Expr); // intermediate values for the realistic calculation -namespace intermediate { +namespace intermediate +{ DECLARE_SOA_COLUMN(HRate, hRate, float); DECLARE_SOA_COLUMN(ClampedTPCMult, clampedTPCmult, float); DECLARE_SOA_COLUMN(Occupancy, occupancy, float); DECLARE_SOA_COLUMN(Correction1, correction1, float); -} +} // namespace intermediate // intermediate table DECLARE_SOA_TABLE(TracksTemporaryExtra, "AOD", "TRKTEMPEX", diff --git a/Benchmarks/src/produce-dynamic-extension-calib.cxx b/Benchmarks/src/produce-dynamic-extension-calib.cxx index 2e41fc64464..9c937897776 100644 --- a/Benchmarks/src/produce-dynamic-extension-calib.cxx +++ b/Benchmarks/src/produce-dynamic-extension-calib.cxx @@ -18,15 +18,14 @@ #include "Framework/AnalysisTask.h" #include "Framework/runDataProcessing.h" - using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; float fReal_fTPCSignalN(float mbb0R, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) { - return ((0.019869f * mbb0R) + (0.0012031f * a1pt) + (-0.0031766f * atgl) + (-0.0058023f * atgl * mbb0R) + (0.00087494f * a1pt * mbb0R) + (0.0020074f * side) + (-0.0010434f * a1pt * a1pt) + (0.011812f)) * occ / 1.e3f + // - ((0.009032f * mbb0R) + (0.0011737f * a1pt) + (-0.0010241f * atgl) + (-0.0075789f * atgl * mbb0R) + (0.00029324f * a1pt * mbb0R) + (0.00052475f * side) + (-0.00045413f * a1pt * a1pt) + (0.0024879f)) * fOccTPCN + // + return ((0.019869f * mbb0R) + (0.0012031f * a1pt) + (-0.0031766f * atgl) + (-0.0058023f * atgl * mbb0R) + (0.00087494f * a1pt * mbb0R) + (0.0020074f * side) + (-0.0010434f * a1pt * a1pt) + (0.011812f)) * occ / 1.e3f + // + ((0.009032f * mbb0R) + (0.0011737f * a1pt) + (-0.0010241f * atgl) + (-0.0075789f * atgl * mbb0R) + (0.00029324f * a1pt * mbb0R) + (0.00052475f * side) + (-0.00045413f * a1pt * a1pt) + (0.0024879f)) * fOccTPCN + // ((0.004255f * mbb0R) + (0.0011954f * a1pt) + (0.0054092f * atgl) + (-0.0033655f * atgl * mbb0R) + (0.00052243f * a1pt * mbb0R) + (-0.0002969f * side) + (-0.00074909f * a1pt * a1pt) + (-0.0075754f)) * fTrackOccMeanN + // ((-0.07925f * mbb0R) + (-0.03737f * a1pt) + (0.0017054f * atgl) + (0.093686f * atgl * mbb0R) + (0.023925f * a1pt * mbb0R) + (-0.0083407f * side) + (0.00336f * a1pt * a1pt) + (1.0461f)); }; diff --git a/Benchmarks/src/produce-expression-calib.cxx b/Benchmarks/src/produce-expression-calib.cxx index 6524f3211fc..841b2956ea8 100644 --- a/Benchmarks/src/produce-expression-calib.cxx +++ b/Benchmarks/src/produce-expression-calib.cxx @@ -24,8 +24,8 @@ using namespace o2::framework::expressions; float fReal_fTPCSignalN(float mbb0R, float a1pt, float atgl, float side, float occ, float fOccTPCN, float fTrackOccMeanN) { - return ((0.019869f * mbb0R) + (0.0012031f * a1pt) + (-0.0031766f * atgl) + (-0.0058023f * atgl * mbb0R) + (0.00087494f * a1pt * mbb0R) + (0.0020074f * side) + (-0.0010434f * a1pt * a1pt) + (0.011812f)) * occ / 1.e3f + // - ((0.009032f * mbb0R) + (0.0011737f * a1pt) + (-0.0010241f * atgl) + (-0.0075789f * atgl * mbb0R) + (0.00029324f * a1pt * mbb0R) + (0.00052475f * side) + (-0.00045413f * a1pt * a1pt) + (0.0024879f)) * fOccTPCN + // + return ((0.019869f * mbb0R) + (0.0012031f * a1pt) + (-0.0031766f * atgl) + (-0.0058023f * atgl * mbb0R) + (0.00087494f * a1pt * mbb0R) + (0.0020074f * side) + (-0.0010434f * a1pt * a1pt) + (0.011812f)) * occ / 1.e3f + // + ((0.009032f * mbb0R) + (0.0011737f * a1pt) + (-0.0010241f * atgl) + (-0.0075789f * atgl * mbb0R) + (0.00029324f * a1pt * mbb0R) + (0.00052475f * side) + (-0.00045413f * a1pt * a1pt) + (0.0024879f)) * fOccTPCN + // ((0.004255f * mbb0R) + (0.0011954f * a1pt) + (0.0054092f * atgl) + (-0.0033655f * atgl * mbb0R) + (0.00052243f * a1pt * mbb0R) + (-0.0002969f * side) + (-0.00074909f * a1pt * a1pt) + (-0.0075754f)) * fTrackOccMeanN + // ((-0.07925f * mbb0R) + (-0.03737f * a1pt) + (0.0017054f * atgl) + (0.093686f * atgl * mbb0R) + (0.023925f * a1pt * mbb0R) + (-0.0083407f * side) + (0.00336f * a1pt * a1pt) + (1.0461f)); }; @@ -99,7 +99,8 @@ struct LeftJoin { struct ProduceExpressionCalib { Defines qacor; - void init(InitContext&) { + void init(InitContext&) + { // realTPCSignal qacor.projectors[0] = ifnode(aod::track::tpcSignal < o2::constants::math::Almost0, LiteralNode{0.f}, From f8381b581e4ea9f0d88c3dd1adf8864f6c2e5a66 Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Wed, 4 Jun 2025 11:14:21 +0200 Subject: [PATCH 9/9] Update CMakeLists.txt --- Benchmarks/CMakeLists.txt | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Benchmarks/CMakeLists.txt b/Benchmarks/CMakeLists.txt index 34839d56dea..8209f5575e0 100644 --- a/Benchmarks/CMakeLists.txt +++ b/Benchmarks/CMakeLists.txt @@ -1,13 +1,13 @@ -# Copyright 2019-2025 CERN and copyright holders of ALICE O2. See -# https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +# Copyright 2019-2025 CERN and copyright holders of ALICE O2. +# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. # All rights not expressly granted are reserved. # -# This software is distributed under the terms of the GNU General Public License -# v3 (GPL Version 3), copied verbatim in the file "COPYING". +# This software is distributed under the terms of the GNU General Public +# License v3 (GPL Version 3), copied verbatim in the file "COPYING". # # In applying this license CERN does not waive the privileges and immunities -# granted to it by virtue of its status as an Intergovernmental Organization or -# submit itself to any jurisdiction. +# granted to it by virtue of its status as an Intergovernmental Organization +# or submit itself to any jurisdiction. include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include")