Project
Loading...
Searching...
No Matches
HistogramRegistry.h
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11
12#ifndef FRAMEWORK_HISTOGRAMREGISTRY_H_
13#define FRAMEWORK_HISTOGRAMREGISTRY_H_
14
16#include "Framework/ASoA.h"
18#include "Framework/Logger.h"
19#include "Framework/OutputRef.h"
25#include "StepTHn.h"
26
27#include <TDataMember.h>
28#include <TDataType.h>
29#include <TArrayL.h>
30#include <THnSparse.h>
31#include <TProfile2D.h>
32#include <fmt/core.h>
33
34#include <concepts>
35#include <deque>
36
37class TList;
38
39#define HIST(name) CONST_STR(name)
40
41namespace o2::framework
42{
43//**************************************************************************************************
47//**************************************************************************************************
48template <typename T>
49concept FillValue = std::is_integral_v<T> || std::is_floating_point_v<T> || std::is_enum_v<T>;
50
51template <typename T, int dimensions>
52concept ValidTH3 = std::same_as<T, TH3> && (dimensions == 3 || dimensions == 4);
53
54template <typename T, int dimensions>
55concept ValidTH2 = std::same_as<T, TH2> && (dimensions == 2 || dimensions == 3);
56
57template <typename T, int dimensions>
58concept ValidTH1 = std::same_as<T, TH1> && (dimensions == 1 || dimensions == 2);
59
60template <typename T, int dimensions>
61concept ValidTProfile3D = std::same_as<T, TProfile3D> && (dimensions == 4 || dimensions == 5);
62
63template <typename T, int dimensions>
64concept ValidTProfile2D = std::same_as<T, TProfile2D> && (dimensions == 3 || dimensions == 4);
65
66template <typename T, int dimensions>
67concept ValidTProfile = std::same_as<T, TProfile> && (dimensions == 2 || dimensions == 3);
68
69template <typename T, int D>
71
72template <typename T, int D>
73concept ValidComplexFill = std::is_base_of_v<THnBase, T>;
74
75template <typename T, int D>
76concept ValidComplexFillStep = std::is_base_of_v<StepTHn, T>;
77
78template <typename T, int D>
80
81struct HistFiller {
82 // fill any type of histogram (if weight was requested it must be the last argument)
83 template <typename T, typename... Ts>
84 static void fillHistAny(std::shared_ptr<T> hist, Ts... positionAndWeight)
85 requires ValidSimpleFill<T, sizeof...(Ts)> && (FillValue<Ts> && ...);
86
87 template <typename T, typename... Ts>
88 static void fillHistAny(std::shared_ptr<T> hist, Ts... positionAndWeight)
89 requires ValidComplexFill<T, sizeof...(Ts)> && (FillValue<Ts> && ...);
90
91 template <typename T, typename... Ts>
92 static void fillHistAny(std::shared_ptr<T> hist, Ts... positionAndWeight)
93 requires ValidComplexFillStep<T, sizeof...(Ts)> && (FillValue<Ts> && ...);
94
95 // This applies only for the non-viable cases
96 template <typename T, typename... Ts>
97 static void fillHistAny(std::shared_ptr<T> hist, Ts... positionAndWeight);
98
99 // fill any type of histogram with columns (Cs) of a filtered table (if weight is requested it must reside the last specified column)
100 template <typename... Cs, typename R, typename T>
101 static void fillHistAny(std::shared_ptr<R> hist, const T& table, const o2::framework::expressions::Filter& filter)
102 requires(!ValidComplexFillStep<R, sizeof...(Cs)>) && requires(T t) { t.asArrowTable(); };
103
104 // fill any type of histogram with columns (Cs) of a filtered table (if weight is requested it must reside the last specified column)
105 template <typename... Cs, typename R, typename T>
106 static void fillHistAny(std::shared_ptr<R> hist, const T& table, const o2::framework::expressions::Filter& filter);
107
108 // function that returns rough estimate for the size of a histogram in MB
109 template <typename T>
110 static double getSize(std::shared_ptr<T> hist, double fillFraction = 1.);
111
112 private:
113 // helper function to determine base element size of histograms (in bytes)
114 template <typename T>
115 static int getBaseElementSize(T* ptr);
116
117 template <typename T, typename Next, typename... Rest, typename P>
118 static int getBaseElementSize(P* ptr);
119
120 template <typename B, typename T>
121 static int getBaseElementSize(T* ptr);
122
123 static void badHistogramFill(char const* name);
124};
125
126//**************************************************************************************************
130//**************************************************************************************************
132{
133 // HistogramName class providing the associated hash and a first guess for the index in the registry
134 struct HistName {
135 // ctor for histogram names that are already hashed at compile time via HIST("myHistName")
136 template <char... chars>
137 constexpr HistName(const ConstStr<chars...>& hashedHistName);
138 char const* const str{};
139 const uint32_t hash{};
140 const uint32_t idx{};
141
142 protected:
143 friend class HistogramRegistry;
144 // ctor that does the hashing at runtime (for internal use only)
145 constexpr HistName(char const* const name);
146 };
147
148 public:
149 HistogramRegistry(char const* const name = "histograms", std::vector<HistogramSpec> histSpecs = {}, OutputObjHandlingPolicy policy = OutputObjHandlingPolicy::AnalysisObject, bool sortHistos = false, bool createRegistryDir = false);
150
151 // functions to add histograms to the registry
152 HistPtr add(const HistogramSpec& histSpec);
153 HistPtr add(char const* const name, char const* const title, const HistogramConfigSpec& histConfigSpec, bool callSumw2 = false);
154 HistPtr add(char const* const name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2 = false);
155 HistPtr add(const std::string& name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2 = false);
156
157 template <typename T>
158 std::shared_ptr<T> add(char const* const name, char const* const title, const HistogramConfigSpec& histConfigSpec, bool callSumw2 = false);
159 template <typename T>
160 std::shared_ptr<T> add(char const* const name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2 = false);
161 template <typename T>
162 std::shared_ptr<T> add(const std::string& name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2 = false);
163
164 void addClone(const std::string& source, const std::string& target);
165
166 // function to query if name is already in use
167 bool contains(const HistName& histName);
168
169 // get the underlying histogram pointer
170 template <typename T>
171 std::shared_ptr<T> get(const HistName& histName);
172
173 template <typename T>
174 std::shared_ptr<T> operator()(const HistName& histName);
175
176 // Apply @a callback on every single entry in the registry
177 void apply(std::function<void(HistogramRegistry const&, TNamed* named)> callback) const;
178 // return the OutputSpec associated to the HistogramRegistry
179 OutputSpec const spec();
180
181 OutputRef ref(uint16_t idx, uint16_t pipelineSize) const;
182
183 void setHash(uint32_t hash);
184
186 void clean();
187
188 // fill hist with values
189 template <typename... Ts>
190 void fill(const HistName& histName, Ts... positionAndWeight)
191 requires(FillValue<Ts> && ...);
192
193 // fill hist with content of (filtered) table columns
194 template <typename... Cs, typename T>
195 void fill(const HistName& histName, const T& table, const o2::framework::expressions::Filter& filter);
196
197 // get rough estimate for size of histogram stored in registry
198 double getSize(const HistName& histName, double fillFraction = 1.);
199
200 // get rough estimate for size of all histograms stored in registry
201 double getSize(double fillFraction = 1.);
202
203 // print summary of the histograms stored in registry
204 void print(bool showAxisDetails = false);
205
206 // lookup distance counter for benchmarking
207 mutable uint32_t lookup = 0;
208
209 private:
210 // create histogram from specification and insert it into the registry
211 HistPtr insert(const HistogramSpec& histSpec);
212
213 // clone an existing histogram and insert it into the registry
214 template <typename T>
215 HistPtr insertClone(const HistName& histName, const std::shared_ptr<T> originalHist);
216
217 // helper function that checks if histogram name can be used in registry
218 void validateHistName(const std::string& name, const uint32_t hash);
219
220 // helper function to find the histogram position in the registry
221 template <typename T>
222 uint32_t getHistIndex(const T& histName) const;
223
224 constexpr uint32_t imask(uint32_t i) const
225 {
226 return i & REGISTRY_BITMASK;
227 }
228
229 // helper function to split user defined path/to/hist/name string
230 std::deque<std::string> splitPath(const std::string& pathAndNameUser);
231
232 // helper function that checks if name of histogram is reasonable and keeps track of names already in use
233 void registerName(const std::string& name);
234
235 std::string mName{};
236 uint32_t nameHash;
237 OutputObjHandlingPolicy mPolicy{};
238 bool mCreateRegistryDir{};
239 bool mSortHistos{};
240 uint32_t mTaskHash{};
241 std::vector<std::string> mRegisteredNames{};
242
243 // the maximum number of histograms in buffer is currently set to 512
244 // which seems to be both reasonably large and allowing for very fast lookup
245 static constexpr uint32_t REGISTRY_BITMASK{0x1FF};
246 static constexpr uint32_t MAX_REGISTRY_SIZE{REGISTRY_BITMASK + 1};
247 std::array<uint32_t, MAX_REGISTRY_SIZE> mRegistryKey{};
248 std::array<HistPtr, MAX_REGISTRY_SIZE> mRegistryValue{};
249};
250
251template <typename T>
252concept is_histogram_registry = std::same_as<T, HistogramRegistry>;
253
254//--------------------------------------------------------------------------------------------------
255//--------------------------------------------------------------------------------------------------
256// Implementation of HistFiller template functions.
257//--------------------------------------------------------------------------------------------------
258//--------------------------------------------------------------------------------------------------
259template <typename T, typename... Ts>
260void HistFiller::fillHistAny(std::shared_ptr<T> hist, Ts... positionAndWeight)
261 requires ValidSimpleFill<T, sizeof...(Ts)> && (FillValue<Ts> && ...)
262{
263 hist->Fill(static_cast<double>(positionAndWeight)...);
264}
265
266template <typename T, typename... Ts>
267void HistFiller::fillHistAny(std::shared_ptr<T> hist, Ts... positionAndWeight)
268 requires ValidComplexFill<T, sizeof...(Ts)> && (FillValue<Ts> && ...)
269{
270 constexpr int nArgs = sizeof...(Ts);
271
272 double tempArray[] = {static_cast<double>(positionAndWeight)...};
273 double weight{1.};
274 constexpr int nArgsMinusOne = nArgs - 1;
275 if (hist->GetNdimensions() == nArgsMinusOne) {
276 weight = tempArray[nArgsMinusOne];
277 } else if (hist->GetNdimensions() != nArgs) {
278 badHistogramFill(hist->GetName());
279 }
280 hist->Fill(tempArray, weight);
281}
282
283template <typename T, typename... Ts>
284void HistFiller::fillHistAny(std::shared_ptr<T> hist, Ts... positionAndWeight)
285 requires ValidComplexFillStep<T, sizeof...(Ts)> && (FillValue<Ts> && ...)
286{
287 hist->Fill(positionAndWeight...); // first argument in pack is iStep, dimension check is done in StepTHn itself
288}
289
290template <typename T, typename... Ts>
291void HistFiller::fillHistAny(std::shared_ptr<T> hist, Ts... positionAndWeight)
292{
293 HistFiller::badHistogramFill(hist->GetName());
294}
295
296template <typename... Cs, typename R, typename T>
297void HistFiller::fillHistAny(std::shared_ptr<R> hist, const T& table, const o2::framework::expressions::Filter& filter)
298 requires(!ValidComplexFillStep<R, sizeof...(Cs)>) && requires(T t) { t.asArrowTable(); }
299{
300 auto s = o2::framework::expressions::createSelection(table.asArrowTable(), filter);
301 auto filtered = o2::soa::Filtered<T>{{table.asArrowTable()}, s};
302 for (auto& t : filtered) {
303 fillHistAny(hist, (*(static_cast<Cs>(t).getIterator()))...);
304 }
305}
306
307template <typename... Cs, typename R, typename T>
308void HistFiller::fillHistAny(std::shared_ptr<R> hist, const T& table, const o2::framework::expressions::Filter& filter)
309{
310 HistFiller::badHistogramFill(hist->GetName());
311}
312
313template <typename T>
314double HistFiller::getSize(std::shared_ptr<T> hist, double fillFraction)
315{
316 double size{0.};
317 if constexpr (std::is_base_of_v<TH1, T>) {
318 size = hist->GetNcells() * (HistFiller::getBaseElementSize(hist.get()) + ((hist->GetSumw2()->fN) ? sizeof(double) : 0.));
319 } else if constexpr (std::is_base_of_v<THn, T>) {
320 size = hist->GetNbins() * (HistFiller::getBaseElementSize(hist.get()) + ((hist->GetSumw2() != -1.) ? sizeof(double) : 0.));
321 } else if constexpr (std::is_base_of_v<THnSparse, T>) {
322 // THnSparse has massive overhead and should only be used when histogram is large and a very small fraction of bins is filled
323 double nBinsTotal = 1.;
324 int compCoordSize = 0; // size required to store a compact coordinate representation
325 for (int d = 0; d < hist->GetNdimensions(); ++d) {
326 int nBins = hist->GetAxis(d)->GetNbins() + 2;
327 nBinsTotal *= nBins;
328
329 // number of bits needed to store compact coordinates
330 int b = 1;
331 while (nBins /= 2) {
332 ++b;
333 }
334 compCoordSize += b;
335 }
336 compCoordSize = (compCoordSize + 7) / 8; // turn bits into bytes
337
338 // THnSparse stores the data in an array of chunks (THnSparseArrayChunk), each containing a fixed number of bins (e.g. 1024 * 16)
339 double nBinsFilled = fillFraction * nBinsTotal;
340 int nCunks = ceil(nBinsFilled / hist->GetChunkSize());
341 int chunkOverhead = sizeof(THnSparseArrayChunk);
342
343 // each chunk holds array of compact bin-coordinates and an array of bin content (+ one of bin error if requested)
344 double binSize = compCoordSize + HistFiller::getBaseElementSize(hist.get()) + ((hist->GetSumw2() != -1.) ? sizeof(double) : 0.);
345 size = nCunks * (chunkOverhead + hist->GetChunkSize() * binSize);
346 // since THnSparse must keep track of all the stored bins, it stores a map that
347 // relates the compact bin coordinates (or a hash thereof) to a linear index
348 // this index determines in which chunk and therein at which position to find / store bin coordinate and content
349 size += nBinsFilled * 3 * sizeof(Long64_t); // hash, key, value; not sure why 3 are needed here...
350 }
351 return size / 1048576.;
352}
353
354template <typename T>
355int HistFiller::getBaseElementSize(T* ptr)
356{
357 if constexpr (std::is_base_of_v<TH1, T> || std::is_base_of_v<THnSparse, T>) {
358 return getBaseElementSize<TArrayD, TArrayF, TArrayC, TArrayI, TArrayC, TArrayL>(ptr);
359 } else {
360 return getBaseElementSize<double, float, int, short, char, long>(ptr);
361 }
362}
363
364template <typename T, typename Next, typename... Rest, typename P>
365int HistFiller::getBaseElementSize(P* ptr)
366{
367 if (auto size = getBaseElementSize<T>(ptr)) {
368 return size;
369 }
370 return getBaseElementSize<Next, Rest...>(ptr);
371}
372
373template <typename B, typename T>
374int HistFiller::getBaseElementSize(T* ptr)
375{
376 if constexpr (std::is_base_of_v<THn, T>) {
377 if (dynamic_cast<THnT<B>*>(ptr)) {
378 return sizeof(B);
379 }
380 } else if constexpr (std::is_base_of_v<THnSparse, T>) {
381 if (dynamic_cast<THnSparseT<B>*>(ptr)) {
382 TDataMember* dm = B::Class()->GetDataMember("fArray");
383 return dm ? dm->GetDataType()->Size() : 0;
384 }
385 } else if constexpr (std::is_base_of_v<TH1, T>) {
386 if (auto arrayPtr = dynamic_cast<B*>(ptr)) {
387 return sizeof(arrayPtr->At(0));
388 }
389 }
390 return 0;
391}
392
393//--------------------------------------------------------------------------------------------------
394//--------------------------------------------------------------------------------------------------
395// Implementation of HistogramRegistry template functions.
396//--------------------------------------------------------------------------------------------------
397//--------------------------------------------------------------------------------------------------
398
399template <char... chars>
400constexpr HistogramRegistry::HistName::HistName(const ConstStr<chars...>& hashedHistName)
401 : str(hashedHistName.str),
402 hash(hashedHistName.hash),
403 idx(hash & REGISTRY_BITMASK)
404{
405}
406
407template <typename T>
408std::shared_ptr<T> HistogramRegistry::add(const std::string& name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2)
409{
410 return add<T>(name.c_str(), title, histType, axes, callSumw2);
411}
412
413template <typename T>
414std::shared_ptr<T> HistogramRegistry::get(const HistName& histName)
415{
416 if (auto histPtr = std::get_if<std::shared_ptr<T>>(&mRegistryValue[getHistIndex(histName)])) {
417 return *histPtr;
418 } else {
419 throw runtime_error_f(R"(Histogram type specified in get<>(HIST("%s")) does not match the actual type of the histogram!)", histName.str);
420 }
421}
422
423template <typename T>
424std::shared_ptr<T> HistogramRegistry::operator()(const HistName& histName)
425{
426 return get<T>(histName);
427}
428
429template <typename T>
430uint32_t HistogramRegistry::getHistIndex(const T& histName) const
431{
432 if (O2_BUILTIN_LIKELY(histName.hash == mRegistryKey[histName.idx])) {
433 return histName.idx;
434 }
435 for (auto i = 1u; i < MAX_REGISTRY_SIZE; ++i) {
436 if (histName.hash == mRegistryKey[imask(histName.idx + i)]) {
437 return imask(histName.idx + i);
438 }
439 }
440 throw runtime_error_f(R"(Could not find histogram "%s" in HistogramRegistry "%s"!)", histName.str, mName.data());
441}
442
443template <typename... Ts>
444void HistogramRegistry::fill(const HistName& histName, Ts... positionAndWeight)
445 requires(FillValue<Ts> && ...)
446{
447 std::visit([positionAndWeight...](auto&& hist) { HistFiller::fillHistAny(hist, positionAndWeight...); }, mRegistryValue[getHistIndex(histName)]);
448}
449
450extern template void HistogramRegistry::fill(const HistName& histName, double);
451extern template void HistogramRegistry::fill(const HistName& histName, float);
452extern template void HistogramRegistry::fill(const HistName& histName, int);
453
454extern template HistPtr HistogramRegistry::insertClone(const HistName&, const std::shared_ptr<TH1>);
455extern template HistPtr HistogramRegistry::insertClone(const HistName&, const std::shared_ptr<TH2>);
456extern template HistPtr HistogramRegistry::insertClone(const HistName&, const std::shared_ptr<TH3>);
457extern template HistPtr HistogramRegistry::insertClone(const HistName&, const std::shared_ptr<TProfile>);
458extern template HistPtr HistogramRegistry::insertClone(const HistName&, const std::shared_ptr<TProfile2D>);
459extern template HistPtr HistogramRegistry::insertClone(const HistName&, const std::shared_ptr<TProfile3D>);
460extern template HistPtr HistogramRegistry::insertClone(const HistName&, const std::shared_ptr<THnSparse>);
461extern template HistPtr HistogramRegistry::insertClone(const HistName&, const std::shared_ptr<THn>);
462extern template HistPtr HistogramRegistry::insertClone(const HistName&, const std::shared_ptr<StepTHn>);
463
464extern template std::shared_ptr<TH1> HistogramRegistry::add<TH1>(char const* const name, char const* const title, const HistogramConfigSpec& histConfigSpec, bool callSumw2);
465extern template std::shared_ptr<TH1> HistogramRegistry::add<TH1>(char const* const name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2);
466extern template std::shared_ptr<TH2> HistogramRegistry::add<TH2>(char const* const name, char const* const title, const HistogramConfigSpec& histConfigSpec, bool callSumw2);
467extern template std::shared_ptr<TH2> HistogramRegistry::add<TH2>(char const* const name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2);
468extern template std::shared_ptr<TH3> HistogramRegistry::add<TH3>(char const* const name, char const* const title, const HistogramConfigSpec& histConfigSpec, bool callSumw2);
469extern template std::shared_ptr<TH3> HistogramRegistry::add<TH3>(char const* const name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2);
470extern template std::shared_ptr<TProfile> HistogramRegistry::add<TProfile>(char const* const name, char const* const title, const HistogramConfigSpec& histConfigSpec, bool callSumw2);
471extern template std::shared_ptr<TProfile> HistogramRegistry::add<TProfile>(char const* const name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2);
472extern template std::shared_ptr<TProfile2D> HistogramRegistry::add<TProfile2D>(char const* const name, char const* const title, const HistogramConfigSpec& histConfigSpec, bool callSumw2);
473extern template std::shared_ptr<TProfile2D> HistogramRegistry::add<TProfile2D>(char const* const name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2);
474extern template std::shared_ptr<TProfile3D> HistogramRegistry::add<TProfile3D>(char const* const name, char const* const title, const HistogramConfigSpec& histConfigSpec, bool callSumw2);
475extern template std::shared_ptr<TProfile3D> HistogramRegistry::add<TProfile3D>(char const* const name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2);
476extern template std::shared_ptr<THn> HistogramRegistry::add<THn>(char const* const name, char const* const title, const HistogramConfigSpec& histConfigSpec, bool callSumw2);
477extern template std::shared_ptr<THn> HistogramRegistry::add<THn>(char const* const name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2);
478extern template std::shared_ptr<THnSparse> HistogramRegistry::add<THnSparse>(char const* const name, char const* const title, const HistogramConfigSpec& histConfigSpec, bool callSumw2);
479extern template std::shared_ptr<THnSparse> HistogramRegistry::add<THnSparse>(char const* const name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2);
480extern template std::shared_ptr<StepTHn> HistogramRegistry::add<StepTHn>(char const* const name, char const* const title, const HistogramConfigSpec& histConfigSpec, bool callSumw2);
481extern template std::shared_ptr<StepTHn> HistogramRegistry::add<StepTHn>(char const* const name, char const* const title, HistType histType, const std::vector<AxisSpec>& axes, bool callSumw2);
482
483template <typename... Cs, typename T>
484void HistogramRegistry::fill(const HistName& histName, const T& table, const o2::framework::expressions::Filter& filter)
485{
486 std::visit([&table, &filter](auto&& hist) { HistFiller::fillHistAny<Cs...>(hist, table, filter); }, mRegistryValue[getHistIndex(histName)]);
487}
488
489} // namespace o2::framework
490#endif // FRAMEWORK_HISTOGRAMREGISTRY_H_
#define O2_BUILTIN_LIKELY(x)
void print() const
int32_t i
Type wrappers for enfording a specific serialization method.
TBranch * ptr
Definition B.h:16
bool contains(const HistName &histName)
double getSize(const HistName &histName, double fillFraction=1.)
void fill(const HistName &histName, Ts... positionAndWeight)
void addClone(const std::string &source, const std::string &target)
std::shared_ptr< T > operator()(const HistName &histName)
HistPtr add(const HistogramSpec &histSpec)
void apply(std::function< void(HistogramRegistry const &, TNamed *named)> callback) const
std::shared_ptr< T > get(const HistName &histName)
void clean()
deletes all the histograms from the registry
GLsizeiptr size
Definition glcorearb.h:659
GLuint const GLchar * name
Definition glcorearb.h:781
GLuint GLuint GLfloat weight
Definition glcorearb.h:5477
GLboolean GLboolean GLboolean b
Definition glcorearb.h:1233
GLsizei GLsizei GLchar * source
Definition glcorearb.h:798
GLenum target
Definition glcorearb.h:1641
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition glcorearb.h:1308
GLint ref
Definition glcorearb.h:291
gandiva::Selection createSelection(std::shared_ptr< arrow::Table > const &table, Filter const &expression)
Function for creating gandiva selection from our internal filter tree.
Defining PrimaryVertex explicitly as messageable.
Definition TFIDInfo.h:20
std::variant< std::shared_ptr< THn >, std::shared_ptr< THnSparse >, std::shared_ptr< TH3 >, std::shared_ptr< TH2 >, std::shared_ptr< TH1 >, std::shared_ptr< TProfile3D >, std::shared_ptr< TProfile2D >, std::shared_ptr< TProfile >, std::shared_ptr< StepTHn > > HistPtr
RuntimeErrorRef runtime_error_f(const char *,...)
OutputObjHandlingPolicy
Policy enum to determine OutputObj handling when writing.
static void fillHistAny(std::shared_ptr< T > hist, Ts... positionAndWeight)
static void fillHistAny(std::shared_ptr< T > hist, Ts... positionAndWeight)
static void fillHistAny(std::shared_ptr< R > hist, const T &table, const o2::framework::expressions::Filter &filter)
static double getSize(std::shared_ptr< T > hist, double fillFraction=1.)
static void fillHistAny(std::shared_ptr< T > hist, Ts... positionAndWeight)
static void fillHistAny(std::shared_ptr< T > hist, Ts... positionAndWeight)
A struct, containing the root of the expression tree.
const std::string str