ATLAS Offline Software
ColumnarPhysliteTest.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 
7 
8 //
9 // includes
10 //
11 
13 
14 #include <AsgTesting/UnitTest.h>
22 #include <xAODJet/JetContainer.h>
26 
30 
31 #ifndef XAOD_STANDALONE
32 #include <POOLRootAccess/TEvent.h>
33 #endif
34 
35 #include <TFile.h>
36 #include <TLeaf.h>
37 #include <TTree.h>
38 
39 #include <chrono>
40 #include <cstdint>
41 #include <memory>
42 #include <vector>
43 
44 #include <gtest/gtest.h>
45 
46 //
47 // method implementations
48 //
49 
50 namespace columnar
51 {
52  namespace
53  {
54  // the target time to run a given tool
55  const auto targetTime = std::chrono::seconds(1);
56 
57  // the number of events per batch in columnar mode
58  const unsigned int batchSize = 1000;
59 
60 
61  class Benchmark final
62  {
63  std::string m_name;
64 
65  std::chrono::time_point<std::chrono::high_resolution_clock> m_start;
66 
69 
72 
73  public:
74  Benchmark (const std::string& val_name)
75  : m_name (val_name)
76  {}
77 
78  ~Benchmark ()
79  {
80  if (m_count > 0)
81  std::cout << m_name << ": " << std::chrono::duration<std::uint64_t,std::nano> (m_ticks) / m_count << std::endl;
82  }
83 
84  auto getTotalTime () const
85  {
86  return m_ticks;
87  }
88 
89  void startTimer ()
90  {
92  }
93 
94  void stopTimer ()
95  {
97  m_count += 1;
98  }
99  };
100  }
101 
102  namespace PhysliteTestHelpers
103  {
104  // I never figured out how the keys get calculated, so I looked
105  // at what's in the input file, and hard-coded it here.
106  static const std::unordered_map<std::string,SG::sgkey_t> knownKeys =
107  {
108  {"AnalysisMuons", 0x3a6b126f},
109  {"AnalysisElectrons", 0x3902fec0},
110  {"AnalysisPhotons", 0x35d1472f},
111  {"AnalysisJets", 0x1afd1919},
112  {"egammaClusters", 0x15788d1f},
113  {"GSFConversionVertices", 0x1f3e85c9},
114  {"InDetTrackParticles", 0x1d3890db},
115  {"CombinedMuonTrackParticles", 0x340d9196},
116  {"ExtrapolatedMuonTrackParticles", 0x14e35e9f},
117  {"GSFTrackParticles", 0x2e42db0b},
118  {"InDetForwardTrackParticles", 0x143c6846},
119  {"MuonSpectrometerTrackParticles", 0x3993c8f3},
120  };
121 
122  template<typename T>
124  {
125  std::string m_branchName;
126  TBranch *m_branch = nullptr;
127  bool m_isStatic = std::is_pod_v<T>;
128  T *m_data {new T()};
129 
130  public:
131  BranchReader (const std::string& val_branchName)
132  : m_branchName (val_branchName)
133  {
134  if (m_branchName.find ("Aux.") != std::string::npos)
135  m_isStatic = true;
136  }
137 
138  ~BranchReader () noexcept
139  {
140  delete m_data;
141  }
142 
143  BranchReader (const BranchReader&) = delete;
145 
146  void setIsStatic (bool isStatic)
147  {
148  m_isStatic = isStatic;
149  }
150 
151  [[nodiscard]] const std::string& branchName () const
152  {
153  return m_branchName;
154  }
155 
156  [[nodiscard]] std::string columnName () const
157  {
158  std::string columnName = m_branchName;
159  if (auto index = columnName.find ("AuxDyn."); index != std::string::npos)
160  columnName.replace (index, 6, "");
161  else if (auto index = columnName.find ("Aux."); index != std::string::npos)
162  columnName.replace (index, 3, "");
163  else if (columnName.find (".") != std::string::npos)
164  throw std::runtime_error ("branch name does not contain AuxDyn or Aux: " + m_branchName);
165  return columnName;
166  }
167 
168  [[nodiscard]] std::string containerName () const
169  {
170  if (auto index = m_branchName.find ("AuxDyn."); index != std::string::npos)
171  return m_branchName.substr (0, index);
172  else if (auto index = m_branchName.find ("Aux."); index != std::string::npos)
173  return m_branchName.substr (0, index);
174  else if (m_branchName.find (".") == std::string::npos)
175  return m_branchName;
176  else
177  throw std::runtime_error ("branch name does not contain AuxDyn or Aux: " + m_branchName);
178  }
179 
180  void connectTree (TTree *tree)
181  {
182  m_branch = tree->GetBranch (m_branchName.c_str());
183  if (!m_branch)
184  throw std::runtime_error ("failed to get branch: " + m_branchName);
185  m_branch->SetMakeClass (1);
186  if (m_isStatic)
187  m_branch->SetAddress (m_data);
188  else
189  m_branch->SetAddress (&m_data);
190  }
191 
192  const T& getEntry (Long64_t entry)
193  {
194  if (!m_branch)
195  throw std::runtime_error ("branch not connected: " + m_branchName);
196  if (m_branch->GetEntry (entry) <= 0)
197  throw std::runtime_error ("failed to get entry " + std::to_string (entry) + " for branch: " + m_branchName);
198  if (m_data == nullptr)
199  throw std::runtime_error ("got nullptr reading data for branch: " + m_branchName);
200  return *m_data;
201  }
202 
203  const T& getCachedEntry () const
204  {
205  return *m_data;
206  }
207  };
208 
209  template<typename T>
211  {
212  public:
213  std::string m_branchName;
214  TBranch *m_branch = nullptr;
215  std::vector<T> m_dataVec;
216 
217  public:
218  BranchReaderArray (const std::string& val_branchName)
219  : m_branchName (val_branchName)
220  {}
221 
224 
225  [[nodiscard]] std::string columnName () const
226  {
227  std::string columnName = m_branchName;
228  if (auto index = columnName.find ("AuxDyn."); index != std::string::npos)
229  columnName.replace (index, 6, "");
230  else if (auto index = columnName.find ("Aux."); index != std::string::npos)
231  columnName.replace (index, 3, "");
232  else if (columnName.find (".") != std::string::npos)
233  throw std::runtime_error ("branch name does not contain AuxDyn or Aux: " + m_branchName);
234  return columnName;
235  }
236 
237  [[nodiscard]] std::string containerName () const
238  {
239  if (auto index = m_branchName.find ("AuxDyn."); index != std::string::npos)
240  return m_branchName.substr (0, index);
241  else if (auto index = m_branchName.find ("Aux."); index != std::string::npos)
242  return m_branchName.substr (0, index);
243  else if (m_branchName.find (".") == std::string::npos)
244  return m_branchName;
245  else
246  throw std::runtime_error ("branch name does not contain AuxDyn or Aux: " + m_branchName);
247  }
248 
249  void connectTree (TTree *tree)
250  {
251  m_branch = tree->GetBranch (m_branchName.c_str());
252  if (!m_branch)
253  throw std::runtime_error ("failed to get branch: " + m_branchName);
254  m_branch->SetMakeClass (1);
255  if (!m_dataVec.empty())
256  m_branch->SetAddress (m_dataVec.data());
257  }
258 
259  std::span<const T> getEntry (Long64_t entry, std::size_t size)
260  {
261  if (!m_branch)
262  throw std::runtime_error ("branch not connected: " + m_branchName);
263  if (m_dataVec.size() < size)
264  {
265  m_dataVec.resize (size);
266  m_branch->SetAddress (m_dataVec.data());
267  }
268  if (size > 0 && m_branch->GetEntry (entry) <= 0)
269  throw std::runtime_error ("failed to get entry " + std::to_string (entry) + " for branch: " + m_branchName);
270  return std::span<const T>(m_dataVec.data(), size);
271  }
272  };
273 
275  {
276  public:
277 
279  {
280  std::string name;
281  bool isOffset = false;
282  bool primary = false;
283  bool enabled = false;
284  };
285  std::vector<OutputColumnInfo> outputColumns;
286 
287  virtual ~IColumnData () noexcept = default;
288 
289  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) = 0;
290 
291  virtual void clearColumns () = 0;
292 
293  virtual void getEntry (Long64_t entry) = 0;
294 
295  virtual void setData (ColumnarToolWrapperData& tool) = 0;
296  };
297 
298  struct ColumnDataEventCount final : public PhysliteTestHelpers::IColumnData
299  {
300  std::array<ColumnarOffsetType, 2> data = {0, 0};
301 
303  {
304  outputColumns.push_back ({.name = numberOfEventsName, .isOffset = true});
305  }
306 
307  virtual bool connect (TTree * /*tree*/, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
308  {
309  if (requestedColumns.contains (outputColumns.at(0).name))
310  {
311  requestedColumns.erase (outputColumns.at(0).name);
312  outputColumns.at(0).enabled = true;
313  return true;
314  }
315  return false;
316  }
317 
318  virtual void clearColumns () override
319  {
320  data[0] = 0;
321  data[1] = 0;
322  }
323 
324  virtual void getEntry (Long64_t /*entry*/) override
325  {
326  data[1] += 1;
327  }
328 
329  virtual void setData (ColumnarToolWrapperData& tool) override
330  {
331  if (outputColumns.at(0).enabled)
332  tool.setColumn (outputColumns.at(0).name, data.size(), data.data());
333  }
334  };
335 
336  template<typename T>
338  {
340  Benchmark benchmarkUnpack;
341  Benchmark benchmark;
342  std::vector<T> outData;
343 
344  explicit ColumnDataScalar (const std::string& val_branchName)
345  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
346  {
347  outputColumns.push_back ({.name = branchReader.columnName()});
348  }
349 
350  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
351  {
352  auto iter = requestedColumns.find (outputColumns.at(0).name);
353  if (iter == requestedColumns.end())
354  return false;
355  outputColumns.at(0).enabled = true;
356  requestedColumns.erase (iter);
357 
358  branchReader.connectTree (tree);
359 
360  return true;
361  }
362 
363  virtual void clearColumns () override
364  {
365  outData.clear ();
366  }
367 
368  virtual void getEntry (Long64_t entry) override
369  {
370  benchmark.startTimer ();
371  const auto& branchData = branchReader.getEntry (entry);
372  benchmark.stopTimer ();
373  benchmarkUnpack.startTimer ();
374  outData.push_back (branchData);
375  benchmarkUnpack.stopTimer ();
376  }
377 
378  virtual void setData (ColumnarToolWrapperData& tool) override
379  {
380  if (outputColumns.at(0).enabled)
381  tool.setColumn (outputColumns.at(0).name, outData.size(), outData.data());
382  }
383  };
384 
385  template<typename T>
387  {
389  const std::vector<ColumnarOffsetType>* offsetColumn = nullptr;
390  std::vector<ColumnarOffsetType> offsets = {0};
391  std::vector<T> outData;
392  Benchmark benchmarkUnpack;
393  Benchmark benchmark;
394 
395  explicit ColumnDataVector (const std::string& val_branchName)
396  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
397  {
398  outputColumns.push_back ({.name = branchReader.columnName()});
399  outputColumns.push_back ({.name = branchReader.containerName(), .isOffset = true, .primary = false});
400  }
401 
402  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
403  {
404  auto iter = requestedColumns.find (outputColumns.at(0).name);
405  if (iter == requestedColumns.end())
406  return false;
407  outputColumns.at(0).enabled = true;
408 
409  branchReader.connectTree (tree);
410 
411  if (iter->second.offsetName != outputColumns.at(1).name)
412  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
413 
414  requestedColumns.erase (iter);
415 
416  if (auto offsetIter = offsetColumns.find (outputColumns.at(1).name); offsetIter != offsetColumns.end())
417  offsetColumn = offsetIter->second;
418  else
419  offsetColumns.emplace (outputColumns.at(1).name, &offsets);
420 
421  iter = requestedColumns.find (outputColumns.at(1).name);
422  if (iter != requestedColumns.end())
423  {
424  requestedColumns.erase (iter);
425  outputColumns.at(1).enabled = true;
426  }
427 
428  return true;
429  }
430 
431  virtual void clearColumns () override
432  {
433  offsets.clear ();
434  offsets.push_back (0);
435  outData.clear ();
436  }
437 
438  virtual void getEntry (Long64_t entry) override
439  {
440  benchmark.startTimer ();
441  const auto& branchData = branchReader.getEntry (entry);
442  benchmark.stopTimer ();
443  benchmarkUnpack.startTimer ();
444  outData.insert (outData.end(), branchData.begin(), branchData.end());
445  offsets.push_back (outData.size());
446  benchmarkUnpack.stopTimer ();
447  }
448 
449  virtual void setData (ColumnarToolWrapperData& tool) override
450  {
451  if (outputColumns.at(0).enabled)
452  tool.setColumn (outputColumns.at(0).name, outData.size(), outData.data());
453  if (outputColumns.at(1).enabled)
454  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
455  if (offsetColumn)
456  {
457  if (offsetColumn->size() != offsets.size())
458  throw std::runtime_error ("offset column not filled yet: " + outputColumns.at(1).name);
459  if (offsetColumn->back() != offsets.back())
460  throw std::runtime_error ("offset column does not match: " + outputColumns.at(1).name);
461  }
462  }
463  };
464 
465  template<typename T>
467  {
469  const std::vector<ColumnarOffsetType>* offsetColumn = nullptr;
470  std::vector<T> outData;
471 
472  ColumnDataOutVector (const std::string& val_columnName, const T& val_defaultValue)
473  : defaultValue (val_defaultValue)
474  {
475  outputColumns.push_back ({.name = val_columnName});
476  }
477 
478  virtual bool connect (TTree * /*tree*/, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
479  {
480  auto iter = requestedColumns.find (outputColumns.at(0).name);
481  if (iter == requestedColumns.end())
482  return false;
483  outputColumns.at(0).enabled = true;
484 
485  // WARNING: absolutely do not switch the next line to a
486  // reference, the pointed to element gets deleted below.
487  const auto offsetName = iter->second.offsetName;
488  if (offsetName.empty())
489  throw std::runtime_error ("missing offset column for: " + outputColumns.at(0).name);
490 
491  requestedColumns.erase (iter);
492 
493  if (auto offsetIter = offsetColumns.find (offsetName); offsetIter != offsetColumns.end())
494  offsetColumn = offsetIter->second;
495  else
496  throw std::runtime_error ("missing offset column for: " + outputColumns.at(0).name);
497  return true;
498  }
499 
500  virtual void clearColumns () override
501  {
502  outData.clear ();
503  }
504 
505  virtual void getEntry (Long64_t /*entry*/) override
506  {
507  outData.resize (offsetColumn->back(), defaultValue);
508  }
509 
510  virtual void setData (ColumnarToolWrapperData& tool) override
511  {
512  if (outputColumns.at(0).enabled)
513  tool.setColumn (outputColumns.at(0).name, outData.size(), outData.data());
514  }
515  };
516 
517  template<typename T>
519  {
521  std::vector<ColumnarOffsetType> offsets = {0};
522  std::vector<T> columnData;
523  Benchmark benchmarkUnpack;
524  Benchmark benchmark;
525 
526  explicit ColumnDataVectorVector (const std::string& val_branchName)
527  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
528  {
529  outputColumns.push_back ({.name = branchReader.columnName() + ".data"});
530  outputColumns.push_back ({.name = branchReader.columnName() + ".offset", .isOffset = true});
531  }
532 
533  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
534  {
535  auto iter = requestedColumns.find (outputColumns.at(0).name);
536  if (iter == requestedColumns.end())
537  return false;
538  outputColumns.at(0).enabled = true;
539 
540  branchReader.connectTree (tree);
541 
542  if (iter->second.offsetName != outputColumns.at(1).name)
543  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
544 
545  requestedColumns.erase (iter);
546 
547  iter = requestedColumns.find (outputColumns.at(1).name);
548  if (iter == requestedColumns.end())
549  return true;
550  requestedColumns.erase (iter);
551  outputColumns.at(1).enabled = true;
552  return true;
553  }
554 
555  virtual void clearColumns () override
556  {
557  columnData.clear();
558  offsets.clear();
559  offsets.push_back (0);
560  }
561 
562  virtual void getEntry (Long64_t entry) override
563  {
564  benchmark.startTimer ();
565  const auto& branchData = branchReader.getEntry (entry);
566  benchmark.stopTimer ();
567  benchmarkUnpack.startTimer ();
568  for (auto& data : branchData)
569  {
570  columnData.insert (columnData.end(), data.begin(), data.end());
571  offsets.push_back (columnData.size());
572  }
573  benchmarkUnpack.stopTimer ();
574  }
575 
576  virtual void setData (ColumnarToolWrapperData& tool) override
577  {
578  if (outputColumns.at(0).enabled)
579  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
580  if (outputColumns.at(1).enabled)
581  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
582  }
583  };
584 
585  template<typename T>
587  {
590  std::vector<ColumnarOffsetType> offsets = {0};
591  std::vector<typename CM::LinkIndexType> columnData;
592  const std::vector<ColumnarOffsetType>* targetOffsetColumn = nullptr;
593  SG::sgkey_t targetKey = 0;
594  std::string targetContainerName;
595  Benchmark benchmarkUnpack;
596  Benchmark benchmark;
597 
598  explicit ColumnDataVectorVectorLink (const std::string& val_branchName)
599  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
600  {
601  outputColumns.push_back ({.name = branchReader.columnName() + ".data"});
602  outputColumns.push_back ({.name = branchReader.columnName() + ".offset", .isOffset = true});
603  }
604 
605  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
606  {
607  auto iter = requestedColumns.find (outputColumns.at(0).name);
608  if (iter == requestedColumns.end())
609  return false;
610  outputColumns.at(0).enabled = true;
611 
612  branchReader.connectTree (tree);
613 
614  if (iter->second.offsetName != outputColumns.at(1).name)
615  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
616 
617  targetContainerName = iter->second.linkToName;
618  if (auto keyIter = knownKeys.find (targetContainerName); keyIter != knownKeys.end())
619  targetKey = keyIter->second;
620  if (auto offsetIter = offsetColumns.find (iter->second.linkToName); offsetIter != offsetColumns.end())
621  targetOffsetColumn = offsetIter->second;
622  else
623  throw std::runtime_error ("missing offset column: " + iter->second.linkToName);
624 
625  requestedColumns.erase (iter);
626 
627  iter = requestedColumns.find (outputColumns.at(1).name);
628  if (iter == requestedColumns.end())
629  return true;
630  requestedColumns.erase (iter);
631  outputColumns.at(1).enabled = true;
632  return true;
633  }
634 
635  virtual void clearColumns () override
636  {
637  columnData.clear();
638  offsets.clear();
639  offsets.push_back (0);
640  }
641 
642  virtual void getEntry (Long64_t entry) override
643  {
644  benchmark.startTimer ();
645  const auto& branchData = branchReader.getEntry (entry);
646  benchmark.stopTimer ();
647  benchmarkUnpack.startTimer ();
648  if (targetOffsetColumn->size() < 2)
649  throw std::runtime_error ("target offset column not yet filled for: " + outputColumns.at(0).name);
650  for (auto& data : branchData)
651  {
652  for (auto& element : data)
653  {
654  if (element.isDefault() || (element.key() == 0 && element.index() == 0))
655  columnData.push_back (invalidObjectIndex);
656  else
657  {
658  columnData.push_back (element.index() + targetOffsetColumn->at (targetOffsetColumn->size()-2));
659  if (element.key() != targetKey)
660  {
661  if (targetKey == 0)
662  {
663  targetKey = element.key();
664  std::cout << "assume target key for " << targetContainerName << " is " << std::hex << targetKey << std::dec << std::endl;
665  } else
666  {
667  throw std::runtime_error(
668  std::format("target key mismatch: {:x} != {:x} for {} with element index {}",
669  element.key(), targetKey, outputColumns.at(0).name, element.index())
670  );
671  }
672  }
673  }
674  }
675  offsets.push_back (columnData.size());
676  }
677  benchmarkUnpack.stopTimer ();
678  }
679 
680  virtual void setData (ColumnarToolWrapperData& tool) override
681  {
682  if (outputColumns.at(0).enabled)
683  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
684  if (outputColumns.at(1).enabled)
685  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
686  }
687  };
688 
689  template<typename T>
691  {
692  std::string columnName;
694  std::vector<ColumnarOffsetType> outerOffsets = {0};
695  std::vector<ColumnarOffsetType> innerOffsets = {0};
696  std::vector<T> columnData;
697  Benchmark benchmarkUnpack;
698  Benchmark benchmark;
699 
700  explicit ColumnDataVectorVectorVector (const std::string& val_branchName)
701  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
702  {
703  outputColumns.push_back ({.name = branchReader.columnName() + ".data"});
704  outputColumns.push_back ({.name = branchReader.columnName() + ".innerOffset", .isOffset = true});
705  outputColumns.push_back ({.name = branchReader.columnName() + ".outerOffset", .isOffset = true});
706  }
707 
708  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
709  {
710  auto iter = requestedColumns.find (outputColumns.at(0).name);
711  if (iter == requestedColumns.end())
712  return false;
713  outputColumns.at(0).enabled = true;
714 
715  branchReader.connectTree (tree);
716 
717  if (iter->second.offsetName != outputColumns.at(1).name)
718  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
719 
720  requestedColumns.erase (iter);
721 
722  iter = requestedColumns.find (outputColumns.at(1).name);
723  if (iter == requestedColumns.end())
724  return true;
725  outputColumns.at(1).enabled = true;
726 
727  if (iter->second.offsetName != outputColumns.at(2).name)
728  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(2).name);
729 
730  requestedColumns.erase (iter);
731 
732  iter = requestedColumns.find (outputColumns.at(2).name);
733  if (iter == requestedColumns.end())
734  return true;
735  outputColumns.at(2).enabled = true;
736  requestedColumns.erase (iter);
737  return true;
738  }
739 
740  virtual void clearColumns () override
741  {
742  columnData.clear();
743  innerOffsets.clear();
744  innerOffsets.push_back (0);
745  outerOffsets.clear();
746  outerOffsets.push_back (0);
747  }
748 
749  virtual void getEntry (Long64_t entry) override
750  {
751  benchmark.startTimer ();
752  const auto& branchData = branchReader.getEntry (entry);
753  benchmark.stopTimer ();
754  benchmarkUnpack.startTimer ();
755  for (auto& outerData : branchData)
756  {
757  for (auto& innerData : outerData)
758  {
759  columnData.insert (columnData.end(), innerData.begin(), innerData.end());
760  innerOffsets.push_back (columnData.size());
761  }
762  outerOffsets.push_back (innerOffsets.size()-1);
763  }
764  benchmarkUnpack.stopTimer ();
765  }
766 
767  virtual void setData (ColumnarToolWrapperData& tool) override
768  {
769  if (outputColumns.at(0).enabled)
770  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
771  if (outputColumns.at(1).enabled)
772  tool.setColumn (outputColumns.at(1).name, innerOffsets.size(), innerOffsets.data());
773  if (outputColumns.at(2).enabled)
774  tool.setColumn (outputColumns.at(2).name, outerOffsets.size(), outerOffsets.data());
775  }
776  };
777 
778  template<typename T>
780  {
783  const std::vector<ColumnarOffsetType>* offsetColumn = nullptr;
784  std::vector<ColumnarOffsetType> offsets = {0};
785  std::vector<typename CM::LinkIndexType> columnData;
786  const std::vector<ColumnarOffsetType>* targetOffsetColumn = nullptr;
787  SG::sgkey_t targetKey = 0;
788  std::string targetContainerName;
789  Benchmark benchmarkUnpack;
790  Benchmark benchmark;
791 
792  ColumnDataVectorLink (const std::string& val_branchName)
793  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
794  {
795  outputColumns.push_back ({.name = branchReader.columnName()});
796  outputColumns.push_back ({.name = branchReader.containerName(), .isOffset = true, .primary = false});
797  }
798 
799  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
800  {
801  auto iter = requestedColumns.find (outputColumns.at(0).name);
802  if (iter == requestedColumns.end())
803  return false;
804  outputColumns.at(0).enabled = true;
805 
806  branchReader.connectTree (tree);
807 
808  if (iter->second.offsetName != outputColumns.at(1).name)
809  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
810 
811  targetContainerName = iter->second.linkToName;
812  if (auto keyIter = knownKeys.find (targetContainerName); keyIter != knownKeys.end())
813  targetKey = keyIter->second;
814  if (auto targetOffsetIter = offsetColumns.find (iter->second.linkToName); targetOffsetIter != offsetColumns.end())
815  targetOffsetColumn = targetOffsetIter->second;
816  else
817  throw std::runtime_error ("missing offset column: " + iter->second.linkToName);
818 
819  requestedColumns.erase (iter);
820 
821  if (auto offsetIter = offsetColumns.find (outputColumns.at(1).name); offsetIter != offsetColumns.end())
822  offsetColumn = offsetIter->second;
823  else
824  offsetColumns.emplace (outputColumns.at(1).name, &offsets);
825 
826  iter = requestedColumns.find (outputColumns.at(1).name);
827  if (iter != requestedColumns.end())
828  {
829  outputColumns.at(1).enabled = true;
830  requestedColumns.erase (iter);
831  }
832 
833  return true;
834  }
835 
836  virtual void clearColumns () override
837  {
838  columnData.clear();
839  offsets.clear();
840  offsets.push_back (0);
841  }
842 
843  virtual void getEntry (Long64_t entry) override
844  {
845  benchmark.startTimer ();
846  const auto& branchData = branchReader.getEntry (entry);
847  benchmark.stopTimer ();
848  benchmarkUnpack.startTimer ();
849  if (targetOffsetColumn->size() < 2)
850  throw std::runtime_error ("target offset column not yet filled for: " + outputColumns.at(0).name);
851  for (auto& element : branchData)
852  {
853  if (element.isDefault())
854  columnData.push_back (invalidObjectIndex);
855  else
856  {
857  columnData.push_back (element.index() + targetOffsetColumn->at (targetOffsetColumn->size()-2));
858  if (element.key() != targetKey)
859  {
860  if (targetKey == 0)
861  {
862  targetKey = element.key();
863  std::cout << "assume target key for " << targetContainerName << " is " << std::hex << targetKey << std::dec << std::endl;
864  } else
865  {
866  throw std::runtime_error ("target key mismatch: " + std::to_string (element.key()) + " != " + std::to_string (targetKey) + " for " + outputColumns.at(0).name);
867  }
868  }
869  }
870  }
871  offsets.push_back (columnData.size());
872  if (offsetColumn)
873  {
874  if (offsetColumn->size() != offsets.size())
875  throw std::runtime_error ("offset column not filled yet: " + outputColumns.at(1).name);
876  if (offsetColumn->back() != offsets.back())
877  throw std::runtime_error ("offset column does not match: " + outputColumns.at(1).name);
878  }
879  benchmarkUnpack.stopTimer ();
880  }
881 
882  virtual void setData (ColumnarToolWrapperData& tool) override
883  {
884  if (outputColumns.at(0).enabled)
885  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
886  if (outputColumns.at(1).enabled)
887  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
888  }
889  };
890 
891  template<typename T>
893  {
898  const std::vector<ColumnarOffsetType>* offsetColumn = nullptr;
899  std::vector<ColumnarOffsetType> offsets = {0};
900  std::vector<typename CM::LinkIndexType> columnData;
901  std::vector<const std::vector<ColumnarOffsetType>*> targetOffsetColumns;
902  std::vector<SG::sgkey_t> targetKeys;
903  std::vector<typename CM::LinkKeyType> keyColumnData;
904  Benchmark benchmarkUnpack;
905  Benchmark benchmark;
906 
907  ColumnDataVectorSplitLink (const std::string& val_branchName)
908  : branchReaderSize (val_branchName), branchReaderKey (val_branchName + ".m_persKey"), branchReaderIndex (val_branchName + ".m_persIndex"), benchmarkUnpack (branchReaderSize.columnName()+"(unpack)"), benchmark (branchReaderSize.columnName())
909  {
910  outputColumns.push_back ({.name = branchReaderSize.columnName()});
911  outputColumns.push_back ({.name = branchReaderSize.containerName(), .isOffset = true, .primary = false});
912  outputColumns.push_back ({.name = branchReaderSize.columnName() + ".keys", .primary = false});
913  }
914 
915  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
916  {
917  auto iter = requestedColumns.find (outputColumns.at(0).name);
918  if (iter == requestedColumns.end())
919  return false;
920  outputColumns.at(0).enabled = true;
921 
922  branchReaderSize.connectTree (tree);
923  branchReaderKey.connectTree (tree);
924  branchReaderIndex.connectTree (tree);
925 
926  if (iter->second.offsetName != outputColumns.at(1).name)
927  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
928 
929  auto linkContainers = iter->second.variantLinkContainers;
930  if (linkContainers.empty())
931  {
932  if (iter->second.linkToName.empty())
933  throw std::runtime_error ("missing link container for: " + outputColumns.at(0).name);
934  linkContainers.push_back (iter->second.linkToName);
935  } else
936  {
937  if (!iter->second.linkToName.empty())
938  throw std::runtime_error ("link container and variant link containers both set for: " + outputColumns.at(0).name);
939  }
940  for (const auto& container : linkContainers)
941  {
942  if (auto keyIter = knownKeys.find (container); keyIter != knownKeys.end())
943  targetKeys.push_back (keyIter->second);
944  else
945  throw std::runtime_error ("no key known for link container: " + container);
946  if (auto targetOffsetIter = offsetColumns.find (container); targetOffsetIter != offsetColumns.end())
947  targetOffsetColumns.push_back (targetOffsetIter->second);
948  else
949  throw std::runtime_error ("missing offset column: " + container);
950  keyColumnData.push_back (keyColumnData.size());
951  }
952  requestedColumns.erase (iter);
953 
954  if (auto offsetIter = offsetColumns.find (outputColumns.at(1).name); offsetIter != offsetColumns.end())
955  offsetColumn = offsetIter->second;
956  else
957  offsetColumns.emplace (outputColumns.at(1).name, &offsets);
958 
959  iter = requestedColumns.find (outputColumns.at(1).name);
960  if (iter != requestedColumns.end())
961  {
962  outputColumns.at(1).enabled = true;
963  requestedColumns.erase (iter);
964  }
965 
966  iter = requestedColumns.find (outputColumns.at(2).name);
967  if (iter != requestedColumns.end())
968  {
969  outputColumns.at(2).enabled = true;
970  requestedColumns.erase (iter);
971  }
972 
973  return true;
974  }
975 
976  virtual void clearColumns () override
977  {
978  columnData.clear();
979  offsets.clear();
980  offsets.push_back (0);
981  }
982 
983  virtual void getEntry (Long64_t entry) override
984  {
985  benchmark.startTimer ();
986  std::size_t branchDataSize = branchReaderSize.getEntry (entry);
987  auto branchDataKey = branchReaderKey.getEntry (entry, branchDataSize);
988  auto branchDataIndex = branchReaderIndex.getEntry (entry, branchDataSize);
989  benchmark.stopTimer ();
990  benchmarkUnpack.startTimer ();
991  for (auto& targetOffsetColumn : targetOffsetColumns)
992  {
993  if (targetOffsetColumn->size() <= offsets.size())
994  throw std::runtime_error ("target offset column not yet filled for: " + outputColumns.at(0).name);
995  }
996  for (std::size_t index = 0; index < branchDataSize; ++index)
997  {
998  if (branchDataIndex[index] == static_cast<UInt_t>(-1))
999  columnData.push_back (invalidObjectIndex);
1000  else
1001  {
1002  CM::LinkIndexType keyIndex = CM::invalidLinkValue;
1003  if (auto keyIter = std::find(targetKeys.begin(), targetKeys.end(), branchDataKey[index]); keyIter != targetKeys.end())
1004  {
1005  keyIndex = std::distance(targetKeys.begin(), keyIter);
1006  } else if (targetKeys.empty())
1007  {
1008  targetKeys.push_back (branchDataKey[index]);
1009  keyIndex = 0;
1010  std::cout << "assume target key for " << outputColumns.at(0).name << " is " << std::hex << branchDataKey[index] << std::dec << std::endl;
1011  } else
1012  {
1013  std::ostringstream error;
1014  error << "target key mismatch: read " << std::hex << branchDataKey[index];
1015  error << ", expected one of";
1016  for (const auto& key : targetKeys)
1017  error << " " << key;
1018  error << " for " << outputColumns.at(0).name;
1019  throw std::runtime_error (std::move (error).str());
1020  }
1021  auto& targetOffsetColumn = *targetOffsetColumns.at(keyIndex);
1022  auto targetOffset = targetOffsetColumn.at (offsets.size()-1);
1023  CM::LinkIndexType linkIndex = branchDataIndex[index];
1024  linkIndex += targetOffset;
1025  if (linkIndex >= targetOffsetColumn.at(offsets.size()))
1026  throw std::runtime_error (std::format ("index out of range for link: {} >= {} (base index {})", outputColumns.at(0).name, linkIndex, targetOffsetColumn.at(offsets.size()), targetOffset));
1027  columnData.push_back (CM::mergeLinkKeyIndex (keyIndex, branchDataIndex[index] + targetOffset));
1028  }
1029  }
1030  offsets.push_back (columnData.size());
1031  if (offsetColumn)
1032  {
1033  if (offsetColumn->size() != offsets.size())
1034  throw std::runtime_error ("offset column not filled yet: " + outputColumns.at(1).name);
1035  if (offsetColumn->back() != offsets.back())
1036  throw std::runtime_error ("offset column does not match: " + outputColumns.at(1).name);
1037  }
1038  benchmarkUnpack.stopTimer ();
1039  }
1040 
1041  virtual void setData (ColumnarToolWrapperData& tool) override
1042  {
1043  if (outputColumns.at(0).enabled)
1044  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
1045  if (outputColumns.at(1).enabled)
1046  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
1047  if (outputColumns.at(2).enabled)
1048  tool.setColumn (outputColumns.at(2).name, keyColumnData.size(), keyColumnData.data());
1049  }
1050  };
1051 
1052  template<typename T>
1054  {
1057  std::vector<ColumnarOffsetType> offsets = {0};
1058  std::vector<typename CM::LinkIndexType> columnData;
1059  std::vector<typename CM::LinkKeyType> keysColumn;
1060  std::vector<std::string> containers;
1061  std::vector<SG::sgkey_t> containerKeys;
1062  std::vector<const std::vector<ColumnarOffsetType>*> containerOffsets;
1063  Benchmark benchmarkUnpack;
1064  Benchmark benchmark;
1065 
1066  bool checkUnknownKeys = false;
1067  std::unordered_map<SG::sgkey_t,std::unordered_set<std::string>> unknownKeys;
1068 
1069  explicit ColumnDataVectorVectorVariantLink (const std::string& val_branchName)
1070  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
1071  {
1072  outputColumns.push_back ({.name = branchReader.columnName() + ".data"});
1073  outputColumns.push_back ({.name = branchReader.columnName() + ".offset", .isOffset = true});
1074  outputColumns.push_back ({.name = branchReader.columnName() + ".keys"});
1075  }
1076 
1078  {
1079  // print unknown keys and containers they may be associated
1080  // with, based on whether they were always within the range of
1081  // elements allowed for the container.
1082  for (auto& [key, forbiddenContainer] : unknownKeys)
1083  {
1084  std::cout << "unknown key: " << std::hex << key << std::dec << ", allowed containers:";
1085  for (const auto& container : containers)
1086  {
1087  if (forbiddenContainer.find (container) == forbiddenContainer.end())
1088  std::cout << " " << container;
1089  }
1090  std::cout << std::endl;
1091  }
1092  }
1093 
1094  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
1095  {
1096  auto iter = requestedColumns.find (outputColumns.at(0).name);
1097  if (iter == requestedColumns.end())
1098  return false;
1099  outputColumns.at(0).enabled = true;
1100 
1101  branchReader.connectTree (tree);
1102 
1103  if (iter->second.offsetName != outputColumns.at(1).name)
1104  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
1105  containers = iter->second.variantLinkContainers;
1106  if (containers.empty() || iter->second.variantLinkKeyColumn.empty())
1107  throw std::runtime_error ("no variant link containers for: " + outputColumns.at(0).name);
1108  if (iter->second.variantLinkKeyColumn != outputColumns.at(2).name)
1109  throw std::runtime_error ("variant link key column mismatch: " + iter->second.variantLinkKeyColumn + " != " + outputColumns.at(2).name);
1110 
1111  for ([[maybe_unused]] auto& container : containers)
1112  {
1113  keysColumn.push_back (keysColumn.size()+1);
1114  containerOffsets.push_back (offsetColumns.at (container));
1115  if (auto iter = knownKeys.find (container); iter != knownKeys.end())
1116  {
1117  containerKeys.push_back (iter->second);
1118  } else
1119  {
1120  checkUnknownKeys = true;
1121  containerKeys.push_back (0u);
1122  }
1123  }
1124 
1125  requestedColumns.erase (iter);
1126 
1127  iter = requestedColumns.find (outputColumns.at(1).name);
1128  if (iter != requestedColumns.end())
1129  {
1130  outputColumns.at(1).enabled = true;
1131  requestedColumns.erase (iter);
1132  }
1133 
1134  iter = requestedColumns.find (outputColumns.at(2).name);
1135  if (iter != requestedColumns.end())
1136  {
1137  outputColumns.at(2).enabled = true;
1138  requestedColumns.erase (iter);
1139  }
1140  return true;
1141  }
1142 
1143  virtual void clearColumns () override
1144  {
1145  columnData.clear();
1146  offsets.clear();
1147  offsets.push_back (0);
1148  }
1149 
1150  virtual void getEntry (Long64_t entry) override
1151  {
1152  benchmark.startTimer ();
1153  const auto& branchData = branchReader.getEntry (entry);
1154  benchmark.stopTimer ();
1155  benchmarkUnpack.startTimer ();
1156  for (auto& data : branchData)
1157  {
1158  for (auto& element : data)
1159  {
1160  if (element.isDefault())
1161  columnData.push_back (invalidObjectIndex);
1162  else
1163  {
1164  typename CM::LinkIndexType key = 0xff;
1165  typename CM::LinkIndexType index = 0;
1166  for (std::size_t i = 0; i < containers.size(); ++i)
1167  {
1168  if (element.key() == containerKeys[i])
1169  {
1170  if (containerOffsets[i]->back() <= element.index())
1171  throw std::runtime_error ("invalid index: " + std::to_string (element.index()) + " in container: " + containers[i] + " with size: " + std::to_string (containerOffsets[i]->back()));
1172  key = keysColumn[i];
1173  if (containerOffsets[i]->size() < 2)
1174  throw std::runtime_error ("container offset not yet filled for: " + containers[i]);
1175  index = containerOffsets[i]->at (containerOffsets[i]->size()-2) + element.index();
1176  break;
1177  }
1178  }
1179  if (key == 0xff && checkUnknownKeys)
1180  {
1181  // this records which containers the unknown key is
1182  // compatible with, so that I may figure out which
1183  // container it is and hard-code it above.
1184  auto& forbiddenContainers = unknownKeys[element.key()];
1185  for (std::size_t i = 0; i < containers.size(); ++i)
1186  {
1187  if (containerOffsets[i]->back() <= containerOffsets[i]->at (containerOffsets[i]->size()-2) + element.index())
1188  forbiddenContainers.insert (containers[i]);
1189  }
1190  }
1191  columnData.push_back (CM::mergeLinkKeyIndex (key, index));
1192  }
1193  }
1194  offsets.push_back (columnData.size());
1195  }
1196  benchmarkUnpack.stopTimer ();
1197  }
1198 
1199  virtual void setData (ColumnarToolWrapperData& tool) override
1200  {
1201  if (outputColumns.at(0).enabled)
1202  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
1203  if (outputColumns.at(1).enabled)
1204  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
1205  if (outputColumns.at(2).enabled)
1206  tool.setColumn (outputColumns.at(2).name, keysColumn.size(), keysColumn.data());
1207  }
1208  };
1209 
1211  {
1213  std::vector<ColumnarOffsetType> offsets = {0};
1214  std::vector<char> columnData;
1215  std::vector<std::size_t> columnHashData;
1216  Benchmark benchmarkUnpack;
1217  Benchmark benchmark;
1218 
1219  ColumnDataMetNames (const std::string& val_branchName)
1220  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
1221  {
1222  outputColumns.push_back ({.name = branchReader.columnName() + ".data"});
1223  outputColumns.push_back ({.name = branchReader.columnName() + ".offset", .isOffset = true});
1224  outputColumns.push_back ({.name = branchReader.columnName() + "Hash"});
1225  }
1226 
1227  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
1228  {
1229  auto iter = requestedColumns.find (outputColumns.at(0).name);
1230  if (iter == requestedColumns.end())
1231  return false;
1232  outputColumns.at(0).enabled = true;
1233 
1234  branchReader.connectTree (tree);
1235 
1236  if (iter->second.offsetName != outputColumns.at(1).name)
1237  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
1238 
1239  requestedColumns.erase (iter);
1240 
1241  iter = requestedColumns.find (outputColumns.at(1).name);
1242  if (iter == requestedColumns.end())
1243  {
1244  return true;
1245  }
1246  outputColumns.at(1).enabled = true;
1247  requestedColumns.erase (iter);
1248 
1249  iter = requestedColumns.find (outputColumns.at(2).name);
1250  if (iter != requestedColumns.end())
1251  {
1252  outputColumns.at(2).enabled = true;
1253  requestedColumns.erase (iter);
1254  }
1255  return true;
1256  }
1257 
1258  virtual void clearColumns () override
1259  {
1260  columnData.clear();
1261  offsets.clear();
1262  offsets.push_back (0);
1263  columnHashData.clear();
1264  }
1265 
1266  virtual void getEntry (Long64_t entry) override
1267  {
1268  benchmark.startTimer ();
1269  const auto& branchData = branchReader.getEntry (entry);
1270  benchmark.stopTimer ();
1271  benchmarkUnpack.startTimer ();
1272  for (auto& data : branchData)
1273  {
1274  columnData.insert (columnData.end(), data.begin(), data.end());
1275  offsets.push_back (columnData.size());
1276  columnHashData.push_back (std::hash<std::string> () (data));
1277  }
1278  benchmarkUnpack.stopTimer ();
1279  }
1280 
1281  virtual void setData (ColumnarToolWrapperData& tool) override
1282  {
1283  if (outputColumns.at(0).enabled)
1284  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
1285  if (outputColumns.at(1).enabled)
1286  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
1287  if (outputColumns.at(2).enabled)
1288  tool.setColumn (outputColumns.at(2).name, columnHashData.size(), columnHashData.data());
1289  }
1290  };
1291 
1293  {
1294  std::vector<std::string> termNames;
1295  const std::vector<ColumnarOffsetType>* offsetColumns = nullptr;
1296  std::vector<ColumnarOffsetType> offsets = {0};
1297  std::vector<ColumnarOffsetType> namesOffsets = {0};
1298  std::vector<char> namesData;
1299  std::vector<std::size_t> namesHash;
1300 
1301  ColumnDataOutputMet (const std::string& val_columnName, std::vector<std::string> val_termNames)
1302  : termNames (std::move (val_termNames))
1303  {
1304  outputColumns.push_back ({.name = val_columnName, .isOffset = true});
1305  outputColumns.push_back ({.name = val_columnName + ".name.data"});
1306  outputColumns.push_back ({.name = val_columnName + ".name.offset", .isOffset = true});
1307  outputColumns.push_back ({.name = val_columnName + ".nameHash"});
1308  }
1309 
1310  virtual bool connect (TTree * /*tree*/, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
1311  {
1312  if (auto iter = requestedColumns.find (outputColumns.at(0).name);
1313  iter != requestedColumns.end())
1314  requestedColumns.erase (iter);
1315  else
1316  return false;
1317  outputColumns.at(0).enabled = true;
1318 
1319  if (auto iter = requestedColumns.find (outputColumns.at(1).name);
1320  iter != requestedColumns.end())
1321  {
1322  outputColumns.at(1).enabled = true;
1323  requestedColumns.erase (iter);
1324  }
1325 
1326  if (auto iter = requestedColumns.find (outputColumns.at(2).name);
1327  iter != requestedColumns.end())
1328  {
1329  outputColumns.at(2).enabled = true;
1330  requestedColumns.erase (iter);
1331  }
1332 
1333  if (auto iter = requestedColumns.find (outputColumns.at(3).name);
1334  iter != requestedColumns.end())
1335  {
1336  outputColumns.at(3).enabled = true;
1337  requestedColumns.erase (iter);
1338  }
1339 
1340  if (auto offsetIter = offsetColumns.find (outputColumns.at(0).name); offsetIter != offsetColumns.end())
1341  throw std::runtime_error ("duplicate size column: " + outputColumns.at(0).name);
1342  offsetColumns.emplace (outputColumns.at(0).name, &offsets);
1343 
1344  return true;
1345  }
1346 
1347  virtual void clearColumns () override
1348  {
1349  offsets.clear ();
1350  offsets.push_back (0);
1351  namesData.clear ();
1352  namesOffsets.clear ();
1353  namesOffsets.push_back (0);
1354  namesHash.clear ();
1355  }
1356 
1357  virtual void getEntry (Long64_t /*entry*/) override
1358  {
1359  for (const auto& termName : termNames)
1360  {
1361  namesData.insert (namesData.end(), termName.begin(), termName.end());
1362  namesOffsets.push_back (namesData.size());
1363  namesHash.push_back (std::hash<std::string> () (termName));
1364  }
1365  offsets.push_back (namesHash.size());
1366  }
1367 
1368  virtual void setData (ColumnarToolWrapperData& tool) override
1369  {
1370  if (outputColumns.at(0).enabled)
1371  tool.setColumn (outputColumns.at(0).name, offsets.size(), offsets.data());
1372  if (outputColumns.at(1).enabled)
1373  tool.setColumn (outputColumns.at(1).name, namesData.size(), namesData.data());
1374  if (outputColumns.at(2).enabled)
1375  tool.setColumn (outputColumns.at(2).name, namesOffsets.size(), namesOffsets.data());
1376  if (outputColumns.at(3).enabled)
1377  tool.setColumn (outputColumns.at(3).name, namesHash.size(), namesHash.data());
1378  }
1379  };
1380 
1382  {
1384  std::vector<ColumnarOffsetType> offsets = {0};
1385  std::vector<std::uint32_t> columnData;
1386  Benchmark benchmarkUnpack;
1387  Benchmark benchmark;
1388 
1389  ColumnDataSamplingPattern (const std::string& val_branchName)
1390  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+".samplingPattern(fallback)(unpack)"), benchmark (branchReader.columnName() + ".samplingPattern(fallback)")
1391  {
1392  outputColumns.push_back ({.name = branchReader.columnName() + ".samplingPattern"});
1393  outputColumns.push_back ({.name = branchReader.columnName(), .isOffset = true, .primary = false});
1394  }
1395 
1396  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
1397  {
1398  auto iter = requestedColumns.find (outputColumns.at(0).name);
1399  if (iter == requestedColumns.end())
1400  return false;
1401  outputColumns.at(0).enabled = true;
1402 
1403  branchReader.connectTree (tree);
1404 
1405  if (iter->second.offsetName != outputColumns.at(1).name)
1406  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
1407 
1408  requestedColumns.erase (iter);
1409 
1410  iter = requestedColumns.find (outputColumns.at(1).name);
1411  if (iter == requestedColumns.end())
1412  {
1413  return true;
1414  }
1415  outputColumns.at(1).enabled = true;
1416  requestedColumns.erase (iter);
1417  return true;
1418  }
1419 
1420  virtual void clearColumns () override
1421  {
1422  columnData.clear();
1423  offsets.clear();
1424  offsets.push_back (0);
1425  }
1426 
1427  virtual void getEntry (Long64_t entry) override
1428  {
1429  benchmark.startTimer ();
1430  const auto& branchData = branchReader.getEntry (entry);
1431  benchmark.stopTimer ();
1432  benchmarkUnpack.startTimer ();
1433  for (auto data : branchData)
1434  {
1435  columnData.push_back (data->samplingPattern());
1436  }
1437  offsets.push_back (columnData.size());
1438  benchmarkUnpack.stopTimer ();
1439  }
1440 
1441  virtual void setData (ColumnarToolWrapperData& tool) override
1442  {
1443  if (outputColumns.at(0).enabled)
1444  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
1445  if (outputColumns.at(1).enabled)
1446  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
1447  }
1448  };
1449  }
1450 
1451 
1454  {
1455  static std::once_flag flag;
1456  std::call_once (flag, [] ()
1457  {
1458 #ifdef XAOD_STANDALONE
1459  xAOD::Init().ignore();
1460 #else
1461  POOL::Init();
1462 #endif
1463  });
1464 
1465  auto *fileName = getenv ("ASG_TEST_FILE_LITE_MC");
1466  if (fileName == nullptr)
1467  throw std::runtime_error ("missing ASG_TEST_FILE_LITE_MC");
1468  file.reset (TFile::Open (fileName, "READ"));
1469  if (!file)
1470  throw std::runtime_error ("failed to open file");
1471  tree = dynamic_cast<TTree*> (file->Get ("CollectionTree"));
1472  if (!tree)
1473  throw std::runtime_error ("failed to open tree");
1474  }
1475 
1477 
1479  {
1480  static std::atomic<unsigned> index = 0;
1481  return "UniquePhysliteTestTool" + std::to_string(++index);
1482  }
1483 
1485  checkMode ()
1486  {
1487  return true;
1488  }
1489 
1491  {
1492  using namespace PhysliteTestHelpers;
1493 
1494  knownColumns.push_back (std::make_shared<ColumnDataEventCount> ());
1495 
1496  tree->SetMakeClass (1);
1497  {
1498  std::unordered_map<std::string,TBranch*> branches;
1499  {
1500  TIter branchIter (tree->GetListOfBranches());
1501  TObject *obj = nullptr;
1502  while ((obj = branchIter()))
1503  {
1504  TBranch *branch = nullptr;
1505  if ((branch = dynamic_cast<TBranch*>(obj)))
1506  {
1507  branches.emplace (branch->GetName(), branch);
1508  TIter subBranchIter (branch->GetListOfBranches());
1509  while ((obj = subBranchIter()))
1510  {
1511  if (auto subBranch = dynamic_cast<TBranch*>(obj))
1512  branches.emplace (subBranch->GetName(), subBranch);
1513  }
1514  }
1515  }
1516  }
1517 
1518  for (const auto& [name, branch] : branches)
1519  {
1520  if (name.find ("AuxDyn.") != std::string::npos ||
1521  name.find ("Aux.") != std::string::npos)
1522  {
1523  TClass *branchClass = nullptr;
1524  EDataType branchType {};
1525  branch->GetExpectedType (branchClass, branchType);
1526  if (branchClass == nullptr)
1527  {
1528  switch (branchType)
1529  {
1530  case kInt_t:
1531  knownColumns.push_back (std::make_shared<ColumnDataScalar<std::int32_t>> (branch->GetName()));
1532  break;
1533  case kUInt_t:
1534  knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint32_t>> (branch->GetName()));
1535  break;
1536  case kULong_t:
1537  knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint64_t>> (branch->GetName()));
1538  break;
1539  case kULong64_t:
1540  knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint64_t>> (branch->GetName()));
1541  break;
1542  case kFloat_t:
1543  knownColumns.push_back (std::make_shared<ColumnDataScalar<float>> (branch->GetName()));
1544  break;
1545  default:
1546  // no-op
1547  break;
1548  }
1549  } else
1550  {
1551  if (*branchClass->GetTypeInfo() == typeid(std::vector<float>))
1552  {
1553  knownColumns.push_back (std::make_shared<ColumnDataVector<float>> (branch->GetName()));
1554  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<char>))
1555  {
1556  knownColumns.push_back (std::make_shared<ColumnDataVector<char>> (branch->GetName()));
1557  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int8_t>))
1558  {
1559  knownColumns.push_back (std::make_shared<ColumnDataVector<std::int8_t>> (branch->GetName()));
1560  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint8_t>))
1561  {
1562  knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint8_t>> (branch->GetName()));
1563  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int16_t>))
1564  {
1565  knownColumns.push_back (std::make_shared<ColumnDataVector<std::int16_t>> (branch->GetName()));
1566  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint16_t>))
1567  {
1568  knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint16_t>> (branch->GetName()));
1569  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int32_t>))
1570  {
1571  knownColumns.push_back (std::make_shared<ColumnDataVector<std::int32_t>> (branch->GetName()));
1572  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint32_t>))
1573  {
1574  knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint32_t>> (branch->GetName()));
1575  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int64_t>))
1576  {
1577  knownColumns.push_back (std::make_shared<ColumnDataVector<std::int64_t>> (branch->GetName()));
1578  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint64_t>))
1579  {
1580  knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint64_t>> (branch->GetName()));
1581  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<float>>))
1582  {
1583  knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> (branch->GetName()));
1584  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::int32_t>>))
1585  {
1586  knownColumns.push_back (std::make_shared<ColumnDataVectorVector<std::int32_t>> (branch->GetName()));
1587  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::uint64_t>>))
1588  {
1589  knownColumns.push_back (std::make_shared<ColumnDataVectorVector<std::uint64_t>> (branch->GetName()));
1590  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::vector<std::size_t>>>))
1591  {
1592  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVector<std::size_t>> (branch->GetName()));
1593  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::vector<unsigned char>>>))
1594  {
1595  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVector<unsigned char>> (branch->GetName()));
1596  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::string>))
1597  {
1598  knownColumns.push_back (std::make_shared<ColumnDataMetNames> (branch->GetName()));
1599  }
1600  }
1601  }
1602  }
1603  }
1604 
1605  // This is a fallback for the case that we don't have an explicit
1606  // `samplingPattern` branch in our input file (i.e. an older file),
1607  // to allow us to still test tools needing it. This is likely not
1608  // something that actual users can do (they need the new files), but
1609  // for testing it seems like a reasonable workaround.
1610  knownColumns.push_back (std::make_shared<ColumnDataSamplingPattern> ("egammaClusters"));
1611 
1612  // For branches that are element links they need to be explicitly
1613  // declared to have the correct xAOD type, correct split setting,
1614  // and correct linked containers.
1615  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::CaloClusterContainer>> ("AnalysisElectronsAuxDyn.caloClusterLinks"));
1616  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::CaloClusterContainer>> ("AnalysisPhotonsAuxDyn.caloClusterLinks"));
1617  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::VertexContainer>> ("AnalysisPhotonsAuxDyn.vertexLinks"));
1618  knownColumns.push_back (std::make_shared<ColumnDataVectorSplitLink<xAOD::TrackParticleContainer>> ("AnalysisMuonsAuxDyn.inDetTrackParticleLink"));
1619  knownColumns.push_back (std::make_shared<ColumnDataVectorSplitLink<xAOD::TrackParticleContainer>> ("AnalysisMuonsAuxDyn.combinedTrackParticleLink"));
1620  knownColumns.push_back (std::make_shared<ColumnDataVectorSplitLink<xAOD::TrackParticleContainer>> ("AnalysisMuonsAuxDyn.extrapolatedMuonSpectrometerTrackParticleLink"));
1621  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::TrackParticleContainer>> ("GSFConversionVerticesAuxDyn.trackParticleLinks"));
1622  knownColumns.push_back (std::make_shared<ColumnDataVectorLink<xAOD::JetContainer>>("METAssoc_AnalysisMETAux.jetLink"));
1623  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVariantLink<xAOD::IParticleContainer>>("METAssoc_AnalysisMETAux.objectLinks"));
1624 
1625  // For METMaker we need to preplace all of the MET terms that we
1626  // expect to be used, that's what this lined does.
1627  knownColumns.push_back (std::make_shared<ColumnDataOutputMet> ("OutputMET", std::vector<std::string>{"Muons", "RefJet", "MuonEloss", "PVSoftTrk"}));
1628 
1629  // For METMaker we need various extra columns to run. This may need
1630  // some work to avoid, but would likey be worth it.
1631  knownColumns.push_back (std::make_shared<ColumnDataOutVector<std::uint16_t>> ("AnalysisMuons.objectType", xAOD::Type::Muon));
1632  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.m", ParticleConstants::muonMassInMeV));
1633  knownColumns.push_back (std::make_shared<ColumnDataOutVector<std::uint16_t>> ("AnalysisJets.objectType", xAOD::Type::Jet));
1634 
1635  // These are columns that represent variables that are normally held
1636  // by METAssociationHelper, or alternatively are decorated on the
1637  // MET terms (even though they are per object).
1638  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.MetObjectWeight", 0));
1639  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisJets.MetObjectWeight", 0));
1640  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisJets.MetObjectWeightSoft", 0));
1641  knownColumns.push_back (std::make_shared<ColumnDataOutVector<MissingETBase::Types::bitmask_t>> ("METAssoc_AnalysisMET.useObjectFlags", 0));
1642  }
1643 
1645  {
1646  using namespace asg::msgUserCode;
1647 
1648  std::unordered_map<std::string,ColumnInfo> requestedColumns;
1649  for (auto& column : toolWrapper.getColumnInfo())
1650  requestedColumns[column.name] = std::move (column);
1651 
1652  for (auto& name : toolWrapper.getColumnNames())
1653  std::cout << "requested columns: " << name << std::endl;
1654 
1655  for (auto& column : knownColumns)
1656  {
1657  if (column->connect (tree, offsetColumns, requestedColumns))
1658  usedColumns.push_back (column);
1659  }
1660 
1661  std::set<std::string> unclaimedColumns;
1662  for (auto& column : requestedColumns)
1663  {
1664  if (!column.second.isOptional)
1665  unclaimedColumns.insert (column.first);
1666  else
1667  std::cout << "optional column not claimed: " << column.first << std::endl;
1668  }
1669  std::erase_if (unclaimedColumns, [&] (auto& columnName)
1670  {
1671  const auto& info = requestedColumns.at (columnName);
1672  if (info.accessMode != ColumnAccessMode::output || !info.fixedDimensions.empty())
1673  return false;
1674  auto offsetIter = std::find_if (usedColumns.begin(), usedColumns.end(), [&] (const std::shared_ptr<PhysliteTestHelpers::IColumnData>& column)
1675  {
1676  for (auto& output : column->outputColumns)
1677  {
1678  if (output.name == info.offsetName)
1679  return true;
1680  }
1681  return false;
1682  });
1683  if (offsetIter == usedColumns.end())
1684  return false;
1685  std::shared_ptr<PhysliteTestHelpers::IColumnData> myColumn;
1686  if (*info.type == typeid(float))
1687  myColumn = std::make_shared<PhysliteTestHelpers::ColumnDataOutVector<float>> (info.name, 0);
1688  else if (*info.type == typeid(char))
1689  myColumn = std::make_shared<PhysliteTestHelpers::ColumnDataOutVector<char>> (info.name, 0);
1690  else if (*info.type == typeid(std::uint16_t))
1691  myColumn = std::make_shared<PhysliteTestHelpers::ColumnDataOutVector<std::uint16_t>> (info.name, 0);
1692  else if (*info.type == typeid(std::uint64_t))
1693  myColumn = std::make_shared<PhysliteTestHelpers::ColumnDataOutVector<std::uint64_t>> (info.name, 0);
1694  else
1695  {
1696  ANA_MSG_WARNING ("unhandled column type: " << info.name << " " << info.type->name());
1697  return false;
1698  }
1699  knownColumns.push_back (myColumn);
1700  if (!myColumn->connect (tree, offsetColumns, requestedColumns))
1701  {
1702  ANA_MSG_WARNING ("failed to connect dynamic output column: " << info.name);
1703  return false;
1704  }
1705  usedColumns.push_back (myColumn);
1706  return true;
1707  });
1708  if (!unclaimedColumns.empty())
1709  {
1710  std::string message = "columns not claimed:";
1711  for (auto& column : unclaimedColumns)
1712  message += " " + column;
1713  throw std::runtime_error (message);
1714  }
1715  }
1716 
1717  void ColumnarPhysLiteTest :: doCall (asg::AsgTool& tool, const std::string& name, const std::string& container, std::function<void(XAODArgs&)> callXAOD, const std::vector<std::pair<std::string,std::string>>& containerRenames, const std::string& sysName)
1718  {
1719  using namespace asg::msgUserCode;
1720 
1721  if (!sysName.empty())
1722  {
1723  auto *sysTool = dynamic_cast<CP::ISystematicsTool*>(&tool);
1724  if (!sysTool)
1725  throw std::runtime_error ("tool does not support systematics");
1726  std::cout << "applying systematic variation: " << sysName << std::endl;
1727  if (sysTool->applySystematicVariation (CP::SystematicSet (sysName)).isFailure())
1728  throw std::runtime_error ("failed to apply systematic variation: " + sysName);
1729  }
1730  if constexpr (columnarAccessMode == 2)
1731  {
1732  auto *myTool = dynamic_cast<ColumnarTool<ColumnarModeArray>*>(&tool);
1733  if (!containerRenames.empty())
1734  renameContainers (*myTool, containerRenames);
1735  ColumnarToolWrapper toolWrapper (myTool);
1736 
1737  setupKnownColumns ();
1738  setupColumns (toolWrapper);
1739 
1740  Benchmark benchmark (name);
1741 
1742  const std::vector<ColumnarOffsetType>* offsetColumn = nullptr;
1743  if (!container.empty())
1744  {
1745  auto iter = offsetColumns.find (container);
1746  if (iter == offsetColumns.end())
1747  throw std::runtime_error ("missing size column: " + container);
1748  offsetColumn = iter->second;
1749  }
1750 
1751  const auto numberOfEvents = tree->GetEntries();
1753  Long64_t entry = 0;
1754  for (; benchmark.getTotalTime() < targetTime; ++entry)
1755  {
1756  ColumnarToolWrapperData columnData (&toolWrapper);
1757  for (auto& column : usedColumns)
1758  column->getEntry (entry % numberOfEvents);
1759  if (offsetColumn)
1760  {
1761  if (entry + 1 == numberOfEvents)
1762  std::cout << "average size: " << float (totalSize + offsetColumn->back()) / numberOfEvents << std::endl;
1763  }
1764  if ((entry + 1) % batchSize == 0)
1765  {
1766  if (offsetColumn)
1767  totalSize += offsetColumn->back();
1768  for (auto& column : usedColumns)
1769  column->setData (columnData);
1770  benchmark.startTimer ();
1771  columnData.call ();
1772  benchmark.stopTimer ();
1773  for (auto& column : usedColumns)
1774  column->clearColumns ();
1775  }
1776  }
1777  std::cout << "Total entries read: " << entry << std::endl;
1778  } else if constexpr (columnarAccessMode == 0)
1779  {
1780  // this test simply doesn't work in Athena
1781 #ifdef XAOD_STANDALONE
1784 #else
1786 #endif
1787  ANA_CHECK_THROW (event.readFrom (file.get()));
1788 
1789 #ifdef XAOD_STANDALONE
1790  Benchmark benchmarkEmptyClear (name + " empty clear");
1791  Benchmark benchmarkCallClear (name + " call clear");
1792  Benchmark benchmarkPrepClear (name + " prep clear");
1793 #endif
1794  Benchmark benchmarkCall (name + " call");
1795  Benchmark benchmarkPrep (name + " prep");
1796  Benchmark benchmarkGetEntry (name + " getEntry");
1797 
1798  const auto numberOfEvents = event.getEntries();
1799 #ifdef XAOD_STANDALONE
1800  std::cout << "known container keys:" << std::endl;
1801  for (auto& [container, key] : columnar::PhysliteTestHelpers::knownKeys)
1802  {
1803  std::cout << std::format (" {} -> 0x{:x}, 0x{:x} -> {}", container, event.getHash (container), key, event.getName (key)) << std::endl;
1804  }
1805 #endif
1806  if (numberOfEvents == 0){
1807  throw std::runtime_error ("ColumnarPhysLiteTest: numberOfEvents == 0");
1808  }
1809  Long64_t entry = 0;
1810 
1811  // Instead of running for a fixed number of events, we run for a
1812  // fixed amount of time. That is because individual tools can
1813  // vary wildly in how long they take to run, and we mostly want to
1814  // make sure that we ran the tool enough to get a precise
1815  // performance estimate. As a fail-safe it also bounds the time
1816  // spend in i/o, which can be significant in Athena, but at a much
1817  // higher level.
1818  for (; benchmarkCall.getTotalTime() < targetTime && benchmarkPrep.getTotalTime() + benchmarkGetEntry.getTotalTime() < 20 * targetTime; ++entry)
1819  {
1820  benchmarkGetEntry.startTimer ();
1821  event.getEntry (entry % numberOfEvents);
1822  benchmarkGetEntry.stopTimer ();
1823  XAODArgs args;
1824  args.inputContainer = container;
1825  args.outputContainer = container + "Copy1";
1826  args.isPrepCall = true;
1827  benchmarkPrep.startTimer ();
1828  callXAOD (args);
1829  benchmarkPrep.stopTimer ();
1830  args.outputContainer = container + "Copy2";
1831  args.isPrepCall = false;
1832 #ifdef XAOD_STANDALONE
1833  benchmarkPrepClear.startTimer ();
1834  store.clear ();
1835  benchmarkPrepClear.stopTimer ();
1836 #endif
1837  benchmarkCall.startTimer ();
1838  callXAOD (args);
1839  benchmarkCall.stopTimer ();
1840 #ifdef XAOD_STANDALONE
1841  benchmarkCallClear.startTimer ();
1842  store.clear ();
1843  benchmarkCallClear.stopTimer ();
1844  benchmarkEmptyClear.startTimer ();
1845  store.clear ();
1846  benchmarkEmptyClear.stopTimer ();
1847 #endif
1848  }
1849  std::cout << "Total entries read: " << entry << std::endl;
1850  }
1851  }
1852 }
columnar::PhysliteTestHelpers::ColumnDataOutVector::outData
std::vector< T > outData
Definition: ColumnarPhysliteTest.cxx:470
CaloCondBlobAlgs_fillNoiseFromASCII.sysName
sysName
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:92
columnar::PhysliteTestHelpers::ColumnDataVectorVector::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:555
columnar::PhysliteTestHelpers::ColumnDataOutVector::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:510
columnar::PhysliteTestHelpers::ColumnDataMetNames::connect
virtual bool connect(TTree *tree, std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &, std::unordered_map< std::string, ColumnInfo > &requestedColumns) override
Definition: ColumnarPhysliteTest.cxx:1227
SGTest::store
TestStore store
Definition: TestStore.cxx:23
columnar::PhysliteTestHelpers::ColumnDataVector::benchmarkUnpack
Benchmark benchmarkUnpack
Definition: ColumnarPhysliteTest.cxx:392
columnar::PhysliteTestHelpers::ColumnDataVector::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:431
columnar::PhysliteTestHelpers::ColumnDataMetNames::columnHashData
std::vector< std::size_t > columnHashData
Definition: ColumnarPhysliteTest.cxx:1215
columnar::PhysliteTestHelpers::BranchReaderArray::BranchReaderArray
BranchReaderArray(const BranchReaderArray &)=delete
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
MissingETAuxAssociationMap_v2.h
columnar::PhysliteTestHelpers::BranchReader::getEntry
const T & getEntry(Long64_t entry)
Definition: ColumnarPhysliteTest.cxx:192
createLinkingScheme.iter
iter
Definition: createLinkingScheme.py:62
asg::AsgTool
Base class for the dual-use tool implementation classes.
Definition: AsgTool.h:47
columnar::PhysliteTestHelpers::ColumnDataVector::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:449
columnar::numberOfEventsName
const std::string numberOfEventsName
the name used for the column containing the number of events
Definition: IColumnarTool.h:38
columnar::PhysliteTestHelpers::ColumnDataMetNames::benchmark
Benchmark benchmark
Definition: ColumnarPhysliteTest.cxx:1217
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::branchReader
BranchReader< std::vector< std::vector< std::vector< T > > > > branchReader
Definition: ColumnarPhysliteTest.cxx:693
columnar::PhysliteTestHelpers::ColumnDataEventCount
Definition: ColumnarPhysliteTest.cxx:299
columnar::PhysliteTestHelpers::ColumnDataEventCount::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:318
vtune_athena.format
format
Definition: vtune_athena.py:14
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
python.CaloAddPedShiftConfig.args
args
Definition: CaloAddPedShiftConfig.py:47
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::ColumnDataVectorVectorVector
ColumnDataVectorVectorVector(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:700
columnar::PhysliteTestHelpers::BranchReaderArray
Definition: ColumnarPhysliteTest.cxx:211
columnar::PhysliteTestHelpers::ColumnDataOutputMet::namesHash
std::vector< std::size_t > namesHash
Definition: ColumnarPhysliteTest.cxx:1299
columnar::PhysliteTestHelpers::BranchReader::~BranchReader
~BranchReader() noexcept
Definition: ColumnarPhysliteTest.cxx:138
index
Definition: index.py:1
columnar::ColumnarPhysLiteTest::setupColumns
void setupColumns(ColumnarToolWrapper &toolWrapper)
Definition: ColumnarPhysliteTest.cxx:1644
columnar::PhysliteTestHelpers::ColumnDataOutputMet::getEntry
virtual void getEntry(Long64_t) override
Definition: ColumnarPhysliteTest.cxx:1357
columnar::PhysliteTestHelpers::BranchReader::columnName
std::string columnName() const
Definition: ColumnarPhysliteTest.cxx:156
ParticleConstants::PDG2011::muonMassInMeV
constexpr double muonMassInMeV
the mass of the muon (in MeV)
Definition: ParticleConstants.h:29
m_count
std::uint64_t m_count
the number of times the timer has been started
Definition: ColumnarPhysliteTest.cxx:71
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::connect
virtual bool connect(TTree *tree, std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &, std::unordered_map< std::string, ColumnInfo > &requestedColumns) override
Definition: ColumnarPhysliteTest.cxx:708
columnar::PhysliteTestHelpers::ColumnDataVector::branchReader
BranchReader< std::vector< T > > branchReader
Definition: ColumnarPhysliteTest.cxx:388
tree
TChain * tree
Definition: tile_monitor.h:30
columnar::ColumnarToolWrapper::getColumnNames
std::vector< std::string > getColumnNames() const
get information on all defined columns
Definition: ColumnarToolWrapper.cxx:262
columnar::PhysliteTestHelpers::IColumnData::clearColumns
virtual void clearColumns()=0
columnar::PhysliteTestHelpers::ColumnDataScalar::benchmark
Benchmark benchmark
Definition: ColumnarPhysliteTest.cxx:341
m_ticks
std::chrono::high_resolution_clock::duration m_ticks
accumulated time m_ticks
Definition: ColumnarPhysliteTest.cxx:68
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
columnar::PhysliteTestHelpers::ColumnDataVectorVector::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:576
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::benchmarkUnpack
Benchmark benchmarkUnpack
Definition: ColumnarPhysliteTest.cxx:1386
DeMoUpdate.column
dictionary column
Definition: DeMoUpdate.py:1110
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::branchReader
BranchReader< xAOD::CaloClusterContainer > branchReader
Definition: ColumnarPhysliteTest.cxx:1383
columnar::ColumnarPhysLiteTest::~ColumnarPhysLiteTest
~ColumnarPhysLiteTest()
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::benchmark
Benchmark benchmark
Definition: ColumnarPhysliteTest.cxx:698
columnar::PhysliteTestHelpers::BranchReaderArray::columnName
std::string columnName() const
Definition: ColumnarPhysliteTest.cxx:225
columnar::PhysliteTestHelpers::ColumnDataOutVector::connect
virtual bool connect(TTree *, std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &offsetColumns, std::unordered_map< std::string, ColumnInfo > &requestedColumns) override
Definition: ColumnarPhysliteTest.cxx:478
columnar::PhysliteTestHelpers::BranchReaderArray::operator=
BranchReaderArray & operator=(const BranchReaderArray &)=delete
columnar::ColumnarPhysLiteTest::ColumnarPhysLiteTest
ColumnarPhysLiteTest()
Definition: ColumnarPhysliteTest.cxx:1453
columnar::PhysliteTestHelpers::IColumnData::OutputColumnInfo
Definition: ColumnarPhysliteTest.cxx:279
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:560
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:1441
m_name
std::string m_name
Definition: ColumnarPhysliteTest.cxx:63
columnar::PhysliteTestHelpers::BranchReader::connectTree
void connectTree(TTree *tree)
Definition: ColumnarPhysliteTest.cxx:180
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:767
ReweightUtils.message
message
Definition: ReweightUtils.py:15
columnar::PhysliteTestHelpers::ColumnDataVectorVector::connect
virtual bool connect(TTree *tree, std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &, std::unordered_map< std::string, ColumnInfo > &requestedColumns) override
Definition: ColumnarPhysliteTest.cxx:533
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
columnar::PhysliteTestHelpers::BranchReaderArray::m_dataVec
std::vector< T > m_dataVec
Definition: ColumnarPhysliteTest.cxx:215
columnar::ColumnAccessMode::output
@ output
an output column
ColumnarPhysliteTest.h
ISystematicsTool.h
POOL::Init
IAppMgrUI * Init(const char *options="POOLRootAccess/basic.opts")
Bootstraps (creates and configures) the Gaudi Application with the provided options file.
Definition: PhysicsAnalysis/POOLRootAccess/src/TEvent.cxx:29
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::benchmark
Benchmark benchmark
Definition: ColumnarPhysliteTest.cxx:1387
columnar::PhysliteTestHelpers::ColumnDataOutputMet::ColumnDataOutputMet
ColumnDataOutputMet(const std::string &val_columnName, std::vector< std::string > val_termNames)
Definition: ColumnarPhysliteTest.cxx:1301
ANA_CHECK_THROW
#define ANA_CHECK_THROW(EXP)
check whether the given expression was successful, throwing an exception on failure
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:339
columnar::PhysliteTestHelpers::BranchReader::m_branchName
std::string m_branchName
Definition: ColumnarPhysliteTest.cxx:125
runLayerRecalibration.branches
list branches
Definition: runLayerRecalibration.py:98
columnar::PhysliteTestHelpers::ColumnDataScalar::getEntry
virtual void getEntry(Long64_t entry) override
Definition: ColumnarPhysliteTest.cxx:368
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::columnData
std::vector< T > columnData
Definition: ColumnarPhysliteTest.cxx:696
columnar::columnarAccessMode
constexpr unsigned columnarAccessMode
Definition: ColumnarDef.h:15
columnar::PhysliteTestHelpers::ColumnDataMetNames::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:1281
columnar::PhysliteTestHelpers::ColumnDataVector::ColumnDataVector
ColumnDataVector(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:395
columnar::ColumnInfo
a struct that contains meta-information about each column that's needed to interface the column with ...
Definition: ColumnInfo.h:35
columnar::ColumnarModeArray::LinkIndexType
std::size_t LinkIndexType
the type used for columns that represent element links
Definition: ColumnarDef.h:68
python.handimod.now
now
Definition: handimod.py:674
columnar::PhysliteTestHelpers::ColumnDataMetNames::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:1258
POOL::TEvent::readFrom
StatusCode readFrom(TFile *file)
Definition: PhysicsAnalysis/POOLRootAccess/src/TEvent.cxx:133
columnar::PhysliteTestHelpers::ColumnDataMetNames::columnData
std::vector< char > columnData
Definition: ColumnarPhysliteTest.cxx:1214
columnar::PhysliteTestHelpers::ColumnDataMetNames
Definition: ColumnarPhysliteTest.cxx:1211
columnar::PhysliteTestHelpers::ColumnDataVector::benchmark
Benchmark benchmark
Definition: ColumnarPhysliteTest.cxx:393
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::getEntry
virtual void getEntry(Long64_t entry) override
Definition: ColumnarPhysliteTest.cxx:749
StateLessPT_NewConfig.primary
primary
Definition: StateLessPT_NewConfig.py:234
columnar::PhysliteTestHelpers::ColumnDataOutVector::getEntry
virtual void getEntry(Long64_t) override
Definition: ColumnarPhysliteTest.cxx:505
columnar::PhysliteTestHelpers::ColumnDataVectorVector
Definition: ColumnarPhysliteTest.cxx:519
columnar::PhysliteTestHelpers::BranchReader::branchName
const std::string & branchName() const
Definition: ColumnarPhysliteTest.cxx:151
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:93
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
columnar::PhysliteTestHelpers::ColumnDataOutVector::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:500
IsoCloseByCorrectionTest.containers
containers
Associate the close-by pflow objects and the calorimeter clusters.
Definition: IsoCloseByCorrectionTest.py:82
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::columnData
std::vector< std::uint32_t > columnData
Definition: ColumnarPhysliteTest.cxx:1385
IColumnarTool.h
ParticleConstants.h
lumiFormat.i
int i
Definition: lumiFormat.py:85
columnar::PhysliteTestHelpers::BranchReader::getCachedEntry
const T & getCachedEntry() const
Definition: ColumnarPhysliteTest.cxx:203
columnar::PhysliteTestHelpers::ColumnDataOutputMet::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:1368
columnar::PhysliteTestHelpers::ColumnDataOutputMet::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:1347
vector
Definition: MultiHisto.h:13
python.CaloAddPedShiftConfig.str
str
Definition: CaloAddPedShiftConfig.py:42
columnar::ColumnarPhysLiteTest::makeUniqueName
std::string makeUniqueName()
make a unique tool name to be used in unit tests
Definition: ColumnarPhysliteTest.cxx:1478
columnar::ColumnarToolWrapperData
a class that holds the columnar data for a single call to ColumnarToolWrapper
Definition: ColumnarToolWrapper.h:136
master.flag
bool flag
Definition: master.py:29
columnar::PhysliteTestHelpers::ColumnDataOutVector::defaultValue
T defaultValue
Definition: ColumnarPhysliteTest.cxx:468
file
TFile * file
Definition: tile_monitor.h:29
columnar::PhysliteTestHelpers::ColumnDataScalar::benchmarkUnpack
Benchmark benchmarkUnpack
Definition: ColumnarPhysliteTest.cxx:340
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:740
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
columnar::PhysliteTestHelpers::ColumnDataVectorVector::ColumnDataVectorVector
ColumnDataVectorVector(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:526
ColumnarTool.h
columnar::PhysliteTestHelpers::ColumnDataOutputMet::connect
virtual bool connect(TTree *, std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &offsetColumns, std::unordered_map< std::string, ColumnInfo > &requestedColumns) override
Definition: ColumnarPhysliteTest.cxx:1310
columnar::renameContainers
void renameContainers(IColumnarTool &tool, const std::vector< std::pair< std::string, std::string >> &renames)
rename containers in the columnar tool
Definition: ColumnarToolHelpers.cxx:23
columnar::size
std::size_t size() const noexcept
Definition: ObjectRange.h:166
columnar::PhysliteTestHelpers::ColumnDataScalar::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:378
python.LArCalib_HVCorrConfig.seconds
seconds
Definition: LArCalib_HVCorrConfig.py:100
m_start
std::chrono::time_point< std::chrono::high_resolution_clock > m_start
Definition: ColumnarPhysliteTest.cxx:65
columnar::PhysliteTestHelpers::BranchReaderArray::containerName
std::string containerName() const
Definition: ColumnarPhysliteTest.cxx:237
columnar::PhysliteTestHelpers::BranchReader::m_isStatic
bool m_isStatic
Definition: ColumnarPhysliteTest.cxx:127
columnar::PhysliteTestHelpers::BranchReader::m_data
T * m_data
Definition: ColumnarPhysliteTest.cxx:128
columnar::PhysliteTestHelpers::BranchReader::containerName
std::string containerName() const
Definition: ColumnarPhysliteTest.cxx:168
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::benchmarkUnpack
Benchmark benchmarkUnpack
Definition: ColumnarPhysliteTest.cxx:697
columnar::final
CM final
Definition: ColumnAccessor.h:106
PixelAthHitMonAlgCfg.duration
duration
Definition: PixelAthHitMonAlgCfg.py:152
columnar::ColumnarPhysLiteTest::setupKnownColumns
void setupKnownColumns()
Definition: ColumnarPhysliteTest.cxx:1490
MissingETBase.h
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern
Definition: ColumnarPhysliteTest.cxx:1382
columnar::PhysliteTestHelpers::IColumnData::setData
virtual void setData(ColumnarToolWrapperData &tool)=0
columnar::PhysliteTestHelpers::ColumnDataVector
Definition: ColumnarPhysliteTest.cxx:387
columnar::PhysliteTestHelpers::ColumnDataOutputMet::namesData
std::vector< char > namesData
Definition: ColumnarPhysliteTest.cxx:1298
columnar::PhysliteTestHelpers::ColumnDataVector::getEntry
virtual void getEntry(Long64_t entry) override
Definition: ColumnarPhysliteTest.cxx:438
columnar::PhysliteTestHelpers::ColumnDataEventCount::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:329
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector
Definition: ColumnarPhysliteTest.cxx:691
columnar::PhysliteTestHelpers::IColumnData::outputColumns
std::vector< OutputColumnInfo > outputColumns
Definition: ColumnarPhysliteTest.cxx:285
ColumnarToolWrapper.h
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
columnar::PhysliteTestHelpers::ColumnDataVectorVector::benchmark
Benchmark benchmark
Definition: ColumnarPhysliteTest.cxx:524
columnar::PhysliteTestHelpers::ColumnDataScalar::outData
std::vector< T > outData
Definition: ColumnarPhysliteTest.cxx:342
POOL::TEvent
Definition: PhysicsAnalysis/POOLRootAccess/POOLRootAccess/TEvent.h:40
columnar::PhysliteTestHelpers::IColumnData::getEntry
virtual void getEntry(Long64_t entry)=0
TEvent.h
columnar::ColumnarToolWrapper::getColumnInfo
std::vector< ColumnInfo > getColumnInfo() const
Definition: ColumnarToolWrapper.cxx:274
columnar::PhysliteTestHelpers::ColumnDataMetNames::getEntry
virtual void getEntry(Long64_t entry) override
Definition: ColumnarPhysliteTest.cxx:1266
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
columnar::PhysliteTestHelpers::IColumnData::OutputColumnInfo::isOffset
bool isOffset
Definition: ColumnarPhysliteTest.cxx:281
columnar::ColumnarToolWrapper
a class that wraps an IColumnarTool for use in Python
Definition: ColumnarToolWrapper.h:36
columnar::PhysliteTestHelpers::ColumnDataVector::outData
std::vector< T > outData
Definition: ColumnarPhysliteTest.cxx:391
columnar::ColumnarPhysLiteTest::doCall
void doCall(asg::AsgTool &tool, const std::string &name, const std::string &container, std::function< void(XAODArgs &)> callXAOD, const std::vector< std::pair< std::string, std::string >> &containerRenames, const std::string &sysName="")
Definition: ColumnarPhysliteTest.cxx:1717
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
columnar::PhysliteTestHelpers::ColumnDataVectorVector::branchReader
BranchReader< std::vector< std::vector< T > > > branchReader
Definition: ColumnarPhysliteTest.cxx:520
columnar::invalidObjectIndex
constexpr ColumnarOffsetType invalidObjectIndex
the value for an invalid element index
Definition: IColumnarTool.h:25
columnar::PhysliteTestHelpers::IColumnData::connect
virtual bool connect(TTree *tree, std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &offsetColumns, std::unordered_map< std::string, ColumnInfo > &requestedColumns)=0
SG::sgkey_t
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition: CxxUtils/CxxUtils/sgkey_t.h:32
columnar::PhysliteTestHelpers::ColumnDataEventCount::ColumnDataEventCount
ColumnDataEventCount()
Definition: ColumnarPhysliteTest.cxx:302
columnar::PhysliteTestHelpers::ColumnDataOutputMet
Definition: ColumnarPhysliteTest.cxx:1293
columnar::PhysliteTestHelpers::IColumnData::OutputColumnInfo::enabled
bool enabled
Definition: ColumnarPhysliteTest.cxx:283
columnar::PhysliteTestHelpers::BranchReader::setIsStatic
void setIsStatic(bool isStatic)
Definition: ColumnarPhysliteTest.cxx:146
columnar::ColumnarModeArray
Definition: ColumnarDef.h:33
columnar::PhysliteTestHelpers::BranchReaderArray::m_branchName
std::string m_branchName
Definition: ColumnarPhysliteTest.cxx:213
Muon
struct TBPatternUnitContext Muon
CP::ISystematicsTool
Interface for all CP tools supporting systematic variations.
Definition: ISystematicsTool.h:32
columnar::PhysliteTestHelpers::IColumnData::OutputColumnInfo::primary
bool primary
Definition: ColumnarPhysliteTest.cxx:282
RTTAlgmain.branch
branch
Definition: RTTAlgmain.py:61
columnar::PhysliteTestHelpers::ColumnDataMetNames::benchmarkUnpack
Benchmark benchmarkUnpack
Definition: ColumnarPhysliteTest.cxx:1216
columnar::PhysliteTestHelpers::ColumnDataVector::connect
virtual bool connect(TTree *tree, std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &offsetColumns, std::unordered_map< std::string, ColumnInfo > &requestedColumns) override
Definition: ColumnarPhysliteTest.cxx:402
DeMoScan.index
string index
Definition: DeMoScan.py:362
python.CaloAddPedShiftConfig.default
default
Definition: CaloAddPedShiftConfig.py:43
VertexContainer.h
xAOD::TStore
A relatively simple transient store for objects created in analysis.
Definition: TStore.h:47
columnar::ColumnarPhysLiteTest::checkMode
static bool checkMode()
check whether we have the right mode
Definition: ColumnarPhysliteTest.cxx:1485
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:1420
columnar::PhysliteTestHelpers::ColumnDataOutVector::ColumnDataOutVector
ColumnDataOutVector(const std::string &val_columnName, const T &val_defaultValue)
Definition: ColumnarPhysliteTest.cxx:472
SCT_ConditionsAlgorithms::CoveritySafe::getenv
std::string getenv(const std::string &variableName)
get an environment variable
Definition: SCT_ConditionsUtilities.cxx:17
columnar::PhysliteTestHelpers::BranchReaderArray::connectTree
void connectTree(TTree *tree)
Definition: ColumnarPhysliteTest.cxx:249
JetContainer.h
columnar
Definition: ClusterDef.h:16
columnar::PhysliteTestHelpers::IColumnData::~IColumnData
virtual ~IColumnData() noexcept=default
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::connect
virtual bool connect(TTree *tree, std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &, std::unordered_map< std::string, ColumnInfo > &requestedColumns) override
Definition: ColumnarPhysliteTest.cxx:1396
columnar::PhysliteTestHelpers::ColumnDataEventCount::getEntry
virtual void getEntry(Long64_t) override
Definition: ColumnarPhysliteTest.cxx:324
columnar::ColumnarTool
the base class for all columnar components
Definition: ColumnAccessorDataArray.h:17
columnar::PhysliteTestHelpers::BranchReader::m_branch
TBranch * m_branch
Definition: ColumnarPhysliteTest.cxx:126
columnar::PhysliteTestHelpers::ColumnDataScalar
Definition: ColumnarPhysliteTest.cxx:338
columnar::PhysliteTestHelpers::ColumnDataScalar::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:363
columnar::PhysliteTestHelpers::IColumnData::OutputColumnInfo::name
std::string name
Definition: ColumnarPhysliteTest.cxx:280
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
columnar::PhysliteTestHelpers::BranchReaderArray::getEntry
std::span< const T > getEntry(Long64_t entry, std::size_t size)
Definition: ColumnarPhysliteTest.cxx:259
columnar::PhysliteTestHelpers::ColumnDataScalar::connect
virtual bool connect(TTree *tree, std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &, std::unordered_map< std::string, ColumnInfo > &requestedColumns) override
Definition: ColumnarPhysliteTest.cxx:350
CaloClusterContainer.h
ColumnarToolHelpers.h
columnar::PhysliteTestHelpers::BranchReaderArray::m_branch
TBranch * m_branch
Definition: ColumnarPhysliteTest.cxx:214
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::ColumnDataSamplingPattern
ColumnDataSamplingPattern(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:1389
python.copyTCTOutput.totalSize
totalSize
Definition: copyTCTOutput.py:90
egammaParameters::linkIndex
@ linkIndex
link index for multiple track and vertex matches
Definition: egammaParamDefs.h:574
columnar::PhysliteTestHelpers::ColumnDataMetNames::ColumnDataMetNames
ColumnDataMetNames(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:1219
jobOptions.fileName
fileName
Definition: jobOptions.SuperChic_ALP2.py:39
ColumnInfo.h
columnar::PhysliteTestHelpers::ColumnDataVectorVector::columnData
std::vector< T > columnData
Definition: ColumnarPhysliteTest.cxx:522
columnar::PhysliteTestHelpers::ColumnDataScalar::ColumnDataScalar
ColumnDataScalar(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:344
columnar::PhysliteTestHelpers::BranchReader
Definition: ColumnarPhysliteTest.cxx:124
get_generator_info.error
error
Definition: get_generator_info.py:40
columnar::PhysliteTestHelpers::BranchReader::operator=
BranchReader & operator=(const BranchReader &)=delete
python.PyAthena.obj
obj
Definition: PyAthena.py:132
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::columnName
std::string columnName
Definition: ColumnarPhysliteTest.cxx:692
columnar::PhysliteTestHelpers::ColumnDataVectorVector::getEntry
virtual void getEntry(Long64_t entry) override
Definition: ColumnarPhysliteTest.cxx:562
error
Definition: IImpactPoint3dEstimator.h:70
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
columnar::ColumnarOffsetType
std::size_t ColumnarOffsetType
the type used for the size and offsets in the columnar data
Definition: IColumnarTool.h:20
columnar::ColumnarPhysLiteTest::XAODArgs
the arguments for the function calling in xAOD mode
Definition: ColumnarPhysliteTest.h:57
UnitTest.h
columnar::PhysliteTestHelpers::ColumnDataOutVector
Definition: ColumnarPhysliteTest.cxx:467
columnar::PhysliteTestHelpers::BranchReaderArray::BranchReaderArray
BranchReaderArray(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:218
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::getEntry
virtual void getEntry(Long64_t entry) override
Definition: ColumnarPhysliteTest.cxx:1427
columnar::PhysliteTestHelpers::ColumnDataMetNames::branchReader
BranchReader< std::vector< std::string > > branchReader
Definition: ColumnarPhysliteTest.cxx:1212
python.ParticleTypeUtil.info
def info
Definition: ParticleTypeUtil.py:87
columnar::PhysliteTestHelpers::ColumnDataOutputMet::termNames
std::vector< std::string > termNames
Definition: ColumnarPhysliteTest.cxx:1294
xAOD::Jet
Jet_v1 Jet
Definition of the current "jet version".
Definition: Event/xAOD/xAODJet/xAODJet/Jet.h:17
columnar::PhysliteTestHelpers::BranchReader::BranchReader
BranchReader(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:131
TrackParticleContainer.h
xAOD::TEvent
Tool for accessing xAOD files outside of Athena.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:85
columnar::PhysliteTestHelpers::ColumnDataVectorVector::benchmarkUnpack
Benchmark benchmarkUnpack
Definition: ColumnarPhysliteTest.cxx:523
columnar::PhysliteTestHelpers::IColumnData
Definition: ColumnarPhysliteTest.cxx:275
columnar::ColumnarToolWrapperData::call
void call()
call the tool
Definition: ColumnarToolWrapper.cxx:210
columnar::PhysliteTestHelpers::BranchReader::BranchReader
BranchReader(const BranchReader &)=delete
columnar::PhysliteTestHelpers::ColumnDataScalar::branchReader
BranchReader< T > branchReader
Definition: ColumnarPhysliteTest.cxx:339
xAOD::Init
StatusCode Init(const char *appname)
Function initialising ROOT/PyROOT for using the ATLAS EDM.
Definition: Init.cxx:31
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
columnar::PhysliteTestHelpers::ColumnDataEventCount::connect
virtual bool connect(TTree *, std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &, std::unordered_map< std::string, ColumnInfo > &requestedColumns) override
Definition: ColumnarPhysliteTest.cxx:307
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37