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>
21 #include <xAODJet/JetContainer.h>
25 
29 
30 #ifndef XAOD_STANDALONE
31 #include <POOLRootAccess/TEvent.h>
32 #endif
33 
34 #include <TFile.h>
35 #include <TLeaf.h>
36 #include <TTree.h>
37 
38 #include <chrono>
39 #include <cstdint>
40 #include <memory>
41 #include <vector>
42 
43 #include <gtest/gtest.h>
44 
45 //
46 // method implementations
47 //
48 
49 namespace columnar
50 {
51  namespace
52  {
53  // the target time to run a given tool
54  const auto targetTime = std::chrono::seconds(1);
55 
56  // the number of events per batch in columnar mode
57  const unsigned int batchSize = 1000;
58 
59 
60  class Benchmark final
61  {
62  std::string m_name;
63 
64  std::chrono::time_point<std::chrono::high_resolution_clock> m_start;
65 
68 
71 
72  public:
73  Benchmark (const std::string& val_name)
74  : m_name (val_name)
75  {}
76 
77  ~Benchmark ()
78  {
79  if (m_count > 0)
80  std::cout << m_name << ": " << std::chrono::duration<std::uint64_t,std::nano> (m_ticks) / m_count << std::endl;
81  }
82 
83  auto getTotalTime () const
84  {
85  return m_ticks;
86  }
87 
88  void startTimer ()
89  {
91  }
92 
93  void stopTimer ()
94  {
96  m_count += 1;
97  }
98  };
99  }
100 
101  namespace PhysliteTestHelpers
102  {
103  // I never figured out how the keys get calculated, so I looked
104  // at what's in the input file, and hard-coded it here.
105  static const std::unordered_map<std::string,SG::sgkey_t> knownKeys =
106  {
107  {"AnalysisMuons", 0x3a6b126f},
108  {"AnalysisElectrons", 0x3902fec0},
109  {"AnalysisPhotons", 0x35d1472f},
110  {"AnalysisJets", 0x1afd1919},
111  {"egammaClusters", 0x15788d1f},
112  {"InDetTrackParticles", 0x2e42db0b},
113  {"GSFConversionVertices", 0x1f3e85c9}
114  };
115 
116  template<typename T>
118  {
119  std::string m_branchName;
120  TBranch *m_branch = nullptr;
121  bool m_isStatic = std::is_pod_v<T>;
122  T *m_data {new T()};
123 
124  public:
125  BranchReader (const std::string& val_branchName)
126  : m_branchName (val_branchName)
127  {
128  if (m_branchName.find ("Aux.") != std::string::npos)
129  m_isStatic = true;
130  }
131 
132  ~BranchReader () noexcept
133  {
134  delete m_data;
135  }
136 
137  BranchReader (const BranchReader&) = delete;
139 
140  [[nodiscard]] std::string columnName () const
141  {
142  std::string columnName = m_branchName;
143  if (auto index = columnName.find ("AuxDyn."); index != std::string::npos)
144  columnName.replace (index, 6, "");
145  else if (auto index = columnName.find ("Aux."); index != std::string::npos)
146  columnName.replace (index, 3, "");
147  else if (columnName.find (".") != std::string::npos)
148  throw std::runtime_error ("branch name does not contain AuxDyn or Aux: " + m_branchName);
149  return columnName;
150  }
151 
152  [[nodiscard]] std::string containerName () const
153  {
154  if (auto index = m_branchName.find ("AuxDyn."); index != std::string::npos)
155  return m_branchName.substr (0, index);
156  else if (auto index = m_branchName.find ("Aux."); index != std::string::npos)
157  return m_branchName.substr (0, index);
158  else if (m_branchName.find (".") == std::string::npos)
159  return m_branchName;
160  else
161  throw std::runtime_error ("branch name does not contain AuxDyn or Aux: " + m_branchName);
162  }
163 
164  void connectTree (TTree *tree)
165  {
166  m_branch = tree->GetBranch (m_branchName.c_str());
167  if (!m_branch)
168  throw std::runtime_error ("failed to get branch: " + m_branchName);
169  m_branch->SetMakeClass (1);
170  if (m_isStatic)
171  m_branch->SetAddress (m_data);
172  else
173  m_branch->SetAddress (&m_data);
174  }
175 
176  const T& getEntry (Long64_t entry)
177  {
178  if (!m_branch)
179  throw std::runtime_error ("branch not connected: " + m_branchName);
180  if (m_branch->GetEntry (entry) <= 0)
181  throw std::runtime_error ("failed to get entry " + std::to_string (entry) + " for branch: " + m_branchName);
182  return *m_data;
183  }
184  };
185 
187  {
188  public:
189 
191  {
192  std::string name;
193  bool isOffset = false;
194  bool primary = false;
195  bool enabled = false;
196  };
197  std::vector<OutputColumnInfo> outputColumns;
198 
199  virtual ~IColumnData () noexcept = default;
200 
201  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) = 0;
202 
203  virtual void clearColumns () = 0;
204 
205  virtual void getEntry (Long64_t entry) = 0;
206 
207  virtual void setData (ColumnarToolWrapperData& tool) = 0;
208  };
209 
210  struct ColumnDataEventCount final : public PhysliteTestHelpers::IColumnData
211  {
212  std::array<ColumnarOffsetType, 2> data = {0, 0};
213 
215  {
216  outputColumns.push_back ({.name = numberOfEventsName, .isOffset = true});
217  }
218 
219  virtual bool connect (TTree * /*tree*/, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
220  {
221  if (requestedColumns.contains (outputColumns.at(0).name))
222  {
223  requestedColumns.erase (outputColumns.at(0).name);
224  outputColumns.at(0).enabled = true;
225  return true;
226  }
227  return false;
228  }
229 
230  virtual void clearColumns () override
231  {
232  data[0] = 0;
233  data[1] = 0;
234  }
235 
236  virtual void getEntry (Long64_t /*entry*/) override
237  {
238  data[1] += 1;
239  }
240 
241  virtual void setData (ColumnarToolWrapperData& tool) override
242  {
243  if (outputColumns.at(0).enabled)
244  tool.setColumn (outputColumns.at(0).name, data.size(), data.data());
245  }
246  };
247 
248  template<typename T>
250  {
252  Benchmark benchmarkUnpack;
253  Benchmark benchmark;
254  std::vector<T> outData;
255 
256  explicit ColumnDataScalar (const std::string& val_branchName)
257  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
258  {
259  outputColumns.push_back ({.name = branchReader.columnName()});
260  }
261 
262  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
263  {
264  auto iter = requestedColumns.find (outputColumns.at(0).name);
265  if (iter == requestedColumns.end())
266  return false;
267  outputColumns.at(0).enabled = true;
268  requestedColumns.erase (iter);
269 
270  branchReader.connectTree (tree);
271 
272  return true;
273  }
274 
275  virtual void clearColumns () override
276  {
277  outData.clear ();
278  }
279 
280  virtual void getEntry (Long64_t entry) override
281  {
282  benchmark.startTimer ();
283  const auto& branchData = branchReader.getEntry (entry);
284  benchmark.stopTimer ();
285  benchmarkUnpack.startTimer ();
286  outData.push_back (branchData);
287  benchmarkUnpack.stopTimer ();
288  }
289 
290  virtual void setData (ColumnarToolWrapperData& tool) override
291  {
292  if (outputColumns.at(0).enabled)
293  tool.setColumn (outputColumns.at(0).name, outData.size(), outData.data());
294  }
295  };
296 
297  template<typename T>
299  {
301  const std::vector<ColumnarOffsetType>* offsetColumn = nullptr;
302  std::vector<ColumnarOffsetType> offsets = {0};
303  std::vector<T> outData;
304  Benchmark benchmarkUnpack;
305  Benchmark benchmark;
306 
307  explicit ColumnDataVector (const std::string& val_branchName)
308  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
309  {
310  outputColumns.push_back ({.name = branchReader.columnName()});
311  outputColumns.push_back ({.name = branchReader.containerName(), .isOffset = true, .primary = false});
312  }
313 
314  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
315  {
316  auto iter = requestedColumns.find (outputColumns.at(0).name);
317  if (iter == requestedColumns.end())
318  return false;
319  outputColumns.at(0).enabled = true;
320 
321  branchReader.connectTree (tree);
322 
323  if (iter->second.offsetName != outputColumns.at(1).name)
324  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
325 
326  requestedColumns.erase (iter);
327 
328  if (auto offsetIter = offsetColumns.find (outputColumns.at(1).name); offsetIter != offsetColumns.end())
329  offsetColumn = offsetIter->second;
330  else
331  offsetColumns.emplace (outputColumns.at(1).name, &offsets);
332 
333  iter = requestedColumns.find (outputColumns.at(1).name);
334  if (iter != requestedColumns.end())
335  {
336  requestedColumns.erase (iter);
337  outputColumns.at(1).enabled = true;
338  }
339 
340  return true;
341  }
342 
343  virtual void clearColumns () override
344  {
345  offsets.clear ();
346  offsets.push_back (0);
347  outData.clear ();
348  }
349 
350  virtual void getEntry (Long64_t entry) override
351  {
352  benchmark.startTimer ();
353  const auto& branchData = branchReader.getEntry (entry);
354  benchmark.stopTimer ();
355  benchmarkUnpack.startTimer ();
356  outData.insert (outData.end(), branchData.begin(), branchData.end());
357  offsets.push_back (outData.size());
358  benchmarkUnpack.stopTimer ();
359  }
360 
361  virtual void setData (ColumnarToolWrapperData& tool) override
362  {
363  if (outputColumns.at(0).enabled)
364  tool.setColumn (outputColumns.at(0).name, outData.size(), outData.data());
365  if (outputColumns.at(1).enabled)
366  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
367  if (offsetColumn)
368  {
369  if (offsetColumn->size() != offsets.size())
370  throw std::runtime_error ("offset column not filled yet: " + outputColumns.at(1).name);
371  if (offsetColumn->back() != offsets.back())
372  throw std::runtime_error ("offset column does not match: " + outputColumns.at(1).name);
373  }
374  }
375  };
376 
377  template<typename T>
379  {
381  const std::vector<ColumnarOffsetType>* offsetColumn = nullptr;
382  std::vector<T> outData;
383 
384  ColumnDataOutVector (const std::string& val_columnName, const T& val_defaultValue)
385  : defaultValue (val_defaultValue)
386  {
387  outputColumns.push_back ({.name = val_columnName});
388  }
389 
390  virtual bool connect (TTree * /*tree*/, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
391  {
392  auto iter = requestedColumns.find (outputColumns.at(0).name);
393  if (iter == requestedColumns.end())
394  return false;
395  outputColumns.at(0).enabled = true;
396 
397  // WARNING: absolutely do not switch the next line to a
398  // reference, the pointed to element gets deleted below.
399  const auto offsetName = iter->second.offsetName;
400  if (offsetName.empty())
401  throw std::runtime_error ("missing offset column for: " + outputColumns.at(0).name);
402 
403  requestedColumns.erase (iter);
404 
405  if (auto offsetIter = offsetColumns.find (offsetName); offsetIter != offsetColumns.end())
406  offsetColumn = offsetIter->second;
407  else
408  throw std::runtime_error ("missing offset column for: " + outputColumns.at(0).name);
409  return true;
410  }
411 
412  virtual void clearColumns () override
413  {
414  outData.clear ();
415  }
416 
417  virtual void getEntry (Long64_t /*entry*/) override
418  {
419  outData.resize (offsetColumn->back(), defaultValue);
420  }
421 
422  virtual void setData (ColumnarToolWrapperData& tool) override
423  {
424  if (outputColumns.at(0).enabled)
425  tool.setColumn (outputColumns.at(0).name, outData.size(), outData.data());
426  }
427  };
428 
429  template<typename T>
431  {
433  std::vector<ColumnarOffsetType> offsets = {0};
434  std::vector<T> columnData;
435  Benchmark benchmarkUnpack;
436  Benchmark benchmark;
437 
438  explicit ColumnDataVectorVector (const std::string& val_branchName)
439  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
440  {
441  outputColumns.push_back ({.name = branchReader.columnName() + ".data"});
442  outputColumns.push_back ({.name = branchReader.columnName() + ".offset", .isOffset = true});
443  }
444 
445  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
446  {
447  auto iter = requestedColumns.find (outputColumns.at(0).name);
448  if (iter == requestedColumns.end())
449  return false;
450  outputColumns.at(0).enabled = true;
451 
452  branchReader.connectTree (tree);
453 
454  if (iter->second.offsetName != outputColumns.at(1).name)
455  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
456 
457  requestedColumns.erase (iter);
458 
459  iter = requestedColumns.find (outputColumns.at(1).name);
460  if (iter == requestedColumns.end())
461  return true;
462  requestedColumns.erase (iter);
463  outputColumns.at(1).enabled = true;
464  return true;
465  }
466 
467  virtual void clearColumns () override
468  {
469  columnData.clear();
470  offsets.clear();
471  offsets.push_back (0);
472  }
473 
474  virtual void getEntry (Long64_t entry) override
475  {
476  benchmark.startTimer ();
477  const auto& branchData = branchReader.getEntry (entry);
478  benchmark.stopTimer ();
479  benchmarkUnpack.startTimer ();
480  for (auto& data : branchData)
481  {
482  columnData.insert (columnData.end(), data.begin(), data.end());
483  offsets.push_back (columnData.size());
484  }
485  benchmarkUnpack.stopTimer ();
486  }
487 
488  virtual void setData (ColumnarToolWrapperData& tool) override
489  {
490  if (outputColumns.at(0).enabled)
491  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
492  if (outputColumns.at(1).enabled)
493  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
494  }
495  };
496 
497  template<typename T>
499  {
501  std::vector<ColumnarOffsetType> offsets = {0};
502  std::vector<ColumnarOffsetType> columnData;
503  const std::vector<ColumnarOffsetType>* targetOffsetColumn = nullptr;
504  SG::sgkey_t targetKey = 0;
505  std::string targetContainerName;
506  Benchmark benchmarkUnpack;
507  Benchmark benchmark;
508 
509  explicit ColumnDataVectorVectorLink (const std::string& val_branchName)
510  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
511  {
512  outputColumns.push_back ({.name = branchReader.columnName() + ".data"});
513  outputColumns.push_back ({.name = branchReader.columnName() + ".offset", .isOffset = true});
514  }
515 
516  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
517  {
518  auto iter = requestedColumns.find (outputColumns.at(0).name);
519  if (iter == requestedColumns.end())
520  return false;
521  outputColumns.at(0).enabled = true;
522 
523  branchReader.connectTree (tree);
524 
525  if (iter->second.offsetName != outputColumns.at(1).name)
526  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
527 
528  targetContainerName = iter->second.linkToName;
529  if (auto keyIter = knownKeys.find (targetContainerName); keyIter != knownKeys.end())
530  targetKey = keyIter->second;
531  if (auto offsetIter = offsetColumns.find (iter->second.linkToName); offsetIter != offsetColumns.end())
532  targetOffsetColumn = offsetIter->second;
533  else
534  throw std::runtime_error ("missing offset column: " + iter->second.linkToName);
535 
536  requestedColumns.erase (iter);
537 
538  iter = requestedColumns.find (outputColumns.at(1).name);
539  if (iter == requestedColumns.end())
540  return true;
541  requestedColumns.erase (iter);
542  outputColumns.at(1).enabled = true;
543  return true;
544  }
545 
546  virtual void clearColumns () override
547  {
548  columnData.clear();
549  offsets.clear();
550  offsets.push_back (0);
551  }
552 
553  virtual void getEntry (Long64_t entry) override
554  {
555  benchmark.startTimer ();
556  const auto& branchData = branchReader.getEntry (entry);
557  benchmark.stopTimer ();
558  benchmarkUnpack.startTimer ();
559  if (targetOffsetColumn->size() < 2)
560  throw std::runtime_error ("target offset column not yet filled for: " + outputColumns.at(0).name);
561  for (auto& data : branchData)
562  {
563  for (auto& element : data)
564  {
565  if (element.isDefault() || (element.key() == 0 && element.index() == 0))
566  columnData.push_back (invalidObjectIndex);
567  else
568  {
569  columnData.push_back (element.index() + targetOffsetColumn->at (targetOffsetColumn->size()-2));
570  if (element.key() != targetKey)
571  {
572  if (targetKey == 0)
573  {
574  targetKey = element.key();
575  std::cout << "assume target key for " << targetContainerName << " is " << std::hex << targetKey << std::dec << std::endl;
576  } else
577  {
578  throw std::runtime_error(
579  std::format("target key mismatch: {:x} != {:x} for {} with element index {}",
580  element.key(), targetKey, outputColumns.at(0).name, element.index())
581  );
582  }
583  }
584  }
585  }
586  offsets.push_back (columnData.size());
587  }
588  benchmarkUnpack.stopTimer ();
589  }
590 
591  virtual void setData (ColumnarToolWrapperData& tool) override
592  {
593  if (outputColumns.at(0).enabled)
594  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
595  if (outputColumns.at(1).enabled)
596  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
597  }
598  };
599 
600  template<typename T>
602  {
603  std::string columnName;
605  std::vector<ColumnarOffsetType> outerOffsets = {0};
606  std::vector<ColumnarOffsetType> innerOffsets = {0};
607  std::vector<T> columnData;
608  Benchmark benchmarkUnpack;
609  Benchmark benchmark;
610 
611  explicit ColumnDataVectorVectorVector (const std::string& val_branchName)
612  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
613  {
614  outputColumns.push_back ({.name = branchReader.columnName() + ".data"});
615  outputColumns.push_back ({.name = branchReader.columnName() + ".innerOffset", .isOffset = true});
616  outputColumns.push_back ({.name = branchReader.columnName() + ".outerOffset", .isOffset = true});
617  }
618 
619  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
620  {
621  auto iter = requestedColumns.find (outputColumns.at(0).name);
622  if (iter == requestedColumns.end())
623  return false;
624  outputColumns.at(0).enabled = true;
625 
626  branchReader.connectTree (tree);
627 
628  if (iter->second.offsetName != outputColumns.at(1).name)
629  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
630 
631  requestedColumns.erase (iter);
632 
633  iter = requestedColumns.find (outputColumns.at(1).name);
634  if (iter == requestedColumns.end())
635  return true;
636  outputColumns.at(1).enabled = true;
637 
638  if (iter->second.offsetName != outputColumns.at(2).name)
639  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(2).name);
640 
641  requestedColumns.erase (iter);
642 
643  iter = requestedColumns.find (outputColumns.at(2).name);
644  if (iter == requestedColumns.end())
645  return true;
646  outputColumns.at(2).enabled = true;
647  requestedColumns.erase (iter);
648  return true;
649  }
650 
651  virtual void clearColumns () override
652  {
653  columnData.clear();
654  innerOffsets.clear();
655  innerOffsets.push_back (0);
656  outerOffsets.clear();
657  outerOffsets.push_back (0);
658  }
659 
660  virtual void getEntry (Long64_t entry) override
661  {
662  benchmark.startTimer ();
663  const auto& branchData = branchReader.getEntry (entry);
664  benchmark.stopTimer ();
665  benchmarkUnpack.startTimer ();
666  for (auto& outerData : branchData)
667  {
668  for (auto& innerData : outerData)
669  {
670  columnData.insert (columnData.end(), innerData.begin(), innerData.end());
671  innerOffsets.push_back (columnData.size());
672  }
673  outerOffsets.push_back (innerOffsets.size()-1);
674  }
675  benchmarkUnpack.stopTimer ();
676  }
677 
678  virtual void setData (ColumnarToolWrapperData& tool) override
679  {
680  if (outputColumns.at(0).enabled)
681  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
682  if (outputColumns.at(1).enabled)
683  tool.setColumn (outputColumns.at(1).name, innerOffsets.size(), innerOffsets.data());
684  if (outputColumns.at(2).enabled)
685  tool.setColumn (outputColumns.at(2).name, outerOffsets.size(), outerOffsets.data());
686  }
687  };
688 
689  template<typename T>
691  {
693  const std::vector<ColumnarOffsetType>* offsetColumn = nullptr;
694  std::vector<ColumnarOffsetType> offsets = {0};
695  std::vector<ColumnarOffsetType> columnData;
696  const std::vector<ColumnarOffsetType>* targetOffsetColumn = nullptr;
697  SG::sgkey_t targetKey = 0;
698  std::string targetContainerName;
699  Benchmark benchmarkUnpack;
700  Benchmark benchmark;
701 
702  ColumnDataVectorLink (const std::string& val_branchName)
703  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
704  {
705  outputColumns.push_back ({.name = branchReader.columnName()});
706  outputColumns.push_back ({.name = branchReader.containerName(), .isOffset = true, .primary = false});
707  }
708 
709  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
710  {
711  auto iter = requestedColumns.find (outputColumns.at(0).name);
712  if (iter == requestedColumns.end())
713  return false;
714  outputColumns.at(0).enabled = true;
715 
716  branchReader.connectTree (tree);
717 
718  if (iter->second.offsetName != outputColumns.at(1).name)
719  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
720 
721  targetContainerName = iter->second.linkToName;
722  if (auto keyIter = knownKeys.find (targetContainerName); keyIter != knownKeys.end())
723  targetKey = keyIter->second;
724  if (auto targetOffsetIter = offsetColumns.find (iter->second.linkToName); targetOffsetIter != offsetColumns.end())
725  targetOffsetColumn = targetOffsetIter->second;
726  else
727  throw std::runtime_error ("missing offset column: " + iter->second.linkToName);
728 
729  requestedColumns.erase (iter);
730 
731  if (auto offsetIter = offsetColumns.find (outputColumns.at(1).name); offsetIter != offsetColumns.end())
732  offsetColumn = offsetIter->second;
733  else
734  offsetColumns.emplace (outputColumns.at(1).name, &offsets);
735 
736  iter = requestedColumns.find (outputColumns.at(1).name);
737  if (iter != requestedColumns.end())
738  {
739  outputColumns.at(1).enabled = true;
740  requestedColumns.erase (iter);
741  }
742 
743  return true;
744  }
745 
746  virtual void clearColumns () override
747  {
748  columnData.clear();
749  offsets.clear();
750  offsets.push_back (0);
751  }
752 
753  virtual void getEntry (Long64_t entry) override
754  {
755  benchmark.startTimer ();
756  const auto& branchData = branchReader.getEntry (entry);
757  benchmark.stopTimer ();
758  benchmarkUnpack.startTimer ();
759  if (targetOffsetColumn->size() < 2)
760  throw std::runtime_error ("target offset column not yet filled for: " + outputColumns.at(0).name);
761  for (auto& element : branchData)
762  {
763  if (element.isDefault())
764  columnData.push_back (invalidObjectIndex);
765  else
766  {
767  columnData.push_back (element.index() + targetOffsetColumn->at (targetOffsetColumn->size()-2));
768  if (element.key() != targetKey)
769  {
770  if (targetKey == 0)
771  {
772  targetKey = element.key();
773  std::cout << "assume target key for " << targetContainerName << " is " << std::hex << targetKey << std::dec << std::endl;
774  } else
775  {
776  throw std::runtime_error ("target key mismatch: " + std::to_string (element.key()) + " != " + std::to_string (targetKey) + " for " + outputColumns.at(0).name);
777  }
778  }
779  }
780  }
781  offsets.push_back (columnData.size());
782  if (offsetColumn)
783  {
784  if (offsetColumn->size() != offsets.size())
785  throw std::runtime_error ("offset column not filled yet: " + outputColumns.at(1).name);
786  if (offsetColumn->back() != offsets.back())
787  throw std::runtime_error ("offset column does not match: " + outputColumns.at(1).name);
788  }
789  benchmarkUnpack.stopTimer ();
790  }
791 
792  virtual void setData (ColumnarToolWrapperData& tool) override
793  {
794  if (outputColumns.at(0).enabled)
795  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
796  if (outputColumns.at(1).enabled)
797  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
798  }
799  };
800 
801  template<typename T>
803  {
805  std::vector<ColumnarOffsetType> offsets = {0};
806  std::vector<ColumnarOffsetType> columnData;
807  std::vector<std::uint8_t> keysColumn;
808  std::vector<std::string> containers;
809  std::vector<SG::sgkey_t> containerKeys;
810  std::vector<const std::vector<ColumnarOffsetType>*> containerOffsets;
811  Benchmark benchmarkUnpack;
812  Benchmark benchmark;
813 
814  bool checkUnknownKeys = false;
815  std::unordered_map<SG::sgkey_t,std::unordered_set<std::string>> unknownKeys;
816 
817  explicit ColumnDataVectorVectorVariantLink (const std::string& val_branchName)
818  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
819  {
820  outputColumns.push_back ({.name = branchReader.columnName() + ".data"});
821  outputColumns.push_back ({.name = branchReader.columnName() + ".offset", .isOffset = true});
822  outputColumns.push_back ({.name = branchReader.columnName() + ".keys"});
823  }
824 
826  {
827  // print unknown keys and containers they may be associated
828  // with, based on whether they were always within the range of
829  // elements allowed for the container.
830  for (auto& [key, forbiddenContainer] : unknownKeys)
831  {
832  std::cout << "unknown key: " << std::hex << key << std::dec << ", allowed containers:";
833  for (const auto& container : containers)
834  {
835  if (forbiddenContainer.find (container) == forbiddenContainer.end())
836  std::cout << " " << container;
837  }
838  std::cout << std::endl;
839  }
840  }
841 
842  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
843  {
844  auto iter = requestedColumns.find (outputColumns.at(0).name);
845  if (iter == requestedColumns.end())
846  return false;
847  outputColumns.at(0).enabled = true;
848 
849  branchReader.connectTree (tree);
850 
851  if (iter->second.offsetName != outputColumns.at(1).name)
852  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
853  containers = iter->second.variantLinkContainers;
854  if (containers.empty() || iter->second.variantLinkKeyColumn.empty())
855  throw std::runtime_error ("no variant link containers for: " + outputColumns.at(0).name);
856  if (iter->second.variantLinkKeyColumn != outputColumns.at(2).name)
857  throw std::runtime_error ("variant link key column mismatch: " + iter->second.variantLinkKeyColumn + " != " + outputColumns.at(2).name);
858 
859  for ([[maybe_unused]] auto& container : containers)
860  {
861  keysColumn.push_back (keysColumn.size()+1);
862  containerOffsets.push_back (offsetColumns.at (container));
863  if (auto iter = knownKeys.find (container); iter != knownKeys.end())
864  {
865  containerKeys.push_back (iter->second);
866  } else
867  {
868  checkUnknownKeys = true;
869  containerKeys.push_back (0u);
870  }
871  }
872 
873  requestedColumns.erase (iter);
874 
875  iter = requestedColumns.find (outputColumns.at(1).name);
876  if (iter != requestedColumns.end())
877  {
878  outputColumns.at(1).enabled = true;
879  requestedColumns.erase (iter);
880  }
881 
882  iter = requestedColumns.find (outputColumns.at(2).name);
883  if (iter != requestedColumns.end())
884  {
885  outputColumns.at(2).enabled = true;
886  requestedColumns.erase (iter);
887  }
888  return true;
889  }
890 
891  virtual void clearColumns () override
892  {
893  columnData.clear();
894  offsets.clear();
895  offsets.push_back (0);
896  }
897 
898  virtual void getEntry (Long64_t entry) override
899  {
900  benchmark.startTimer ();
901  const auto& branchData = branchReader.getEntry (entry);
902  benchmark.stopTimer ();
903  benchmarkUnpack.startTimer ();
904  for (auto& data : branchData)
905  {
906  for (auto& element : data)
907  {
908  if (element.isDefault())
909  columnData.push_back (invalidObjectIndex);
910  else
911  {
912  ColumnarOffsetType key = 0xff;
914  for (std::size_t i = 0; i < containers.size(); ++i)
915  {
916  if (element.key() == containerKeys[i])
917  {
918  if (containerOffsets[i]->back() <= element.index())
919  throw std::runtime_error ("invalid index: " + std::to_string (element.index()) + " in container: " + containers[i] + " with size: " + std::to_string (containerOffsets[i]->back()));
920  key = keysColumn[i];
921  if (containerOffsets[i]->size() < 2)
922  throw std::runtime_error ("container offset not yet filled for: " + containers[i]);
923  index = containerOffsets[i]->at (containerOffsets[i]->size()-2) + element.index();
924  break;
925  }
926  }
927  if (key == 0xff && checkUnknownKeys)
928  {
929  // this records which containers the unknown key is
930  // compatible with, so that I may figure out which
931  // container it is and hard-code it above.
932  auto& forbiddenContainers = unknownKeys[element.key()];
933  for (std::size_t i = 0; i < containers.size(); ++i)
934  {
935  if (containerOffsets[i]->back() <= containerOffsets[i]->at (containerOffsets[i]->size()-2) + element.index())
936  forbiddenContainers.insert (containers[i]);
937  }
938  }
939  columnData.push_back (index | (key << 8*(sizeof(ColumnarOffsetType)-1)));
940  }
941  }
942  offsets.push_back (columnData.size());
943  }
944  benchmarkUnpack.stopTimer ();
945  }
946 
947  virtual void setData (ColumnarToolWrapperData& tool) override
948  {
949  if (outputColumns.at(0).enabled)
950  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
951  if (outputColumns.at(1).enabled)
952  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
953  if (outputColumns.at(2).enabled)
954  tool.setColumn (outputColumns.at(2).name, keysColumn.size(), keysColumn.data());
955  }
956  };
957 
959  {
961  std::vector<ColumnarOffsetType> offsets = {0};
962  std::vector<char> columnData;
963  std::vector<std::size_t> columnHashData;
964  Benchmark benchmarkUnpack;
965  Benchmark benchmark;
966 
967  ColumnDataMetNames (const std::string& val_branchName)
968  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+"(unpack)"), benchmark (branchReader.columnName())
969  {
970  outputColumns.push_back ({.name = branchReader.columnName() + ".data"});
971  outputColumns.push_back ({.name = branchReader.columnName() + ".offset", .isOffset = true});
972  outputColumns.push_back ({.name = branchReader.columnName() + "Hash"});
973  }
974 
975  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
976  {
977  auto iter = requestedColumns.find (outputColumns.at(0).name);
978  if (iter == requestedColumns.end())
979  return false;
980  outputColumns.at(0).enabled = true;
981 
982  branchReader.connectTree (tree);
983 
984  if (iter->second.offsetName != outputColumns.at(1).name)
985  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
986 
987  requestedColumns.erase (iter);
988 
989  iter = requestedColumns.find (outputColumns.at(1).name);
990  if (iter == requestedColumns.end())
991  {
992  return true;
993  }
994  outputColumns.at(1).enabled = true;
995  requestedColumns.erase (iter);
996 
997  iter = requestedColumns.find (outputColumns.at(2).name);
998  if (iter != requestedColumns.end())
999  {
1000  outputColumns.at(2).enabled = true;
1001  requestedColumns.erase (iter);
1002  }
1003  return true;
1004  }
1005 
1006  virtual void clearColumns () override
1007  {
1008  columnData.clear();
1009  offsets.clear();
1010  offsets.push_back (0);
1011  columnHashData.clear();
1012  }
1013 
1014  virtual void getEntry (Long64_t entry) override
1015  {
1016  benchmark.startTimer ();
1017  const auto& branchData = branchReader.getEntry (entry);
1018  benchmark.stopTimer ();
1019  benchmarkUnpack.startTimer ();
1020  for (auto& data : branchData)
1021  {
1022  columnData.insert (columnData.end(), data.begin(), data.end());
1023  offsets.push_back (columnData.size());
1024  columnHashData.push_back (std::hash<std::string> () (data));
1025  }
1026  benchmarkUnpack.stopTimer ();
1027  }
1028 
1029  virtual void setData (ColumnarToolWrapperData& tool) override
1030  {
1031  if (outputColumns.at(0).enabled)
1032  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
1033  if (outputColumns.at(1).enabled)
1034  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
1035  if (outputColumns.at(2).enabled)
1036  tool.setColumn (outputColumns.at(2).name, columnHashData.size(), columnHashData.data());
1037  }
1038  };
1039 
1041  {
1042  std::vector<std::string> termNames;
1043  const std::vector<ColumnarOffsetType>* offsetColumns = nullptr;
1044  std::vector<ColumnarOffsetType> offsets = {0};
1045  std::vector<ColumnarOffsetType> namesOffsets = {0};
1046  std::vector<char> namesData;
1047  std::vector<std::size_t> namesHash;
1048 
1049  ColumnDataOutputMet (const std::string& val_columnName, std::vector<std::string> val_termNames)
1050  : termNames (std::move (val_termNames))
1051  {
1052  outputColumns.push_back ({.name = val_columnName, .isOffset = true});
1053  outputColumns.push_back ({.name = val_columnName + ".name.data"});
1054  outputColumns.push_back ({.name = val_columnName + ".name.offset", .isOffset = true});
1055  outputColumns.push_back ({.name = val_columnName + ".nameHash"});
1056  }
1057 
1058  virtual bool connect (TTree * /*tree*/, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
1059  {
1060  if (auto iter = requestedColumns.find (outputColumns.at(0).name);
1061  iter != requestedColumns.end())
1062  requestedColumns.erase (iter);
1063  else
1064  return false;
1065  outputColumns.at(0).enabled = true;
1066 
1067  if (auto iter = requestedColumns.find (outputColumns.at(1).name);
1068  iter != requestedColumns.end())
1069  {
1070  outputColumns.at(1).enabled = true;
1071  requestedColumns.erase (iter);
1072  }
1073 
1074  if (auto iter = requestedColumns.find (outputColumns.at(2).name);
1075  iter != requestedColumns.end())
1076  {
1077  outputColumns.at(2).enabled = true;
1078  requestedColumns.erase (iter);
1079  }
1080 
1081  if (auto iter = requestedColumns.find (outputColumns.at(3).name);
1082  iter != requestedColumns.end())
1083  {
1084  outputColumns.at(3).enabled = true;
1085  requestedColumns.erase (iter);
1086  }
1087 
1088  if (auto offsetIter = offsetColumns.find (outputColumns.at(0).name); offsetIter != offsetColumns.end())
1089  throw std::runtime_error ("duplicate size column: " + outputColumns.at(0).name);
1090  offsetColumns.emplace (outputColumns.at(0).name, &offsets);
1091 
1092  return true;
1093  }
1094 
1095  virtual void clearColumns () override
1096  {
1097  offsets.clear ();
1098  offsets.push_back (0);
1099  namesData.clear ();
1100  namesOffsets.clear ();
1101  namesOffsets.push_back (0);
1102  namesHash.clear ();
1103  }
1104 
1105  virtual void getEntry (Long64_t /*entry*/) override
1106  {
1107  for (const auto& termName : termNames)
1108  {
1109  namesData.insert (namesData.end(), termName.begin(), termName.end());
1110  namesOffsets.push_back (namesData.size());
1111  namesHash.push_back (std::hash<std::string> () (termName));
1112  }
1113  offsets.push_back (namesHash.size());
1114  }
1115 
1116  virtual void setData (ColumnarToolWrapperData& tool) override
1117  {
1118  if (outputColumns.at(0).enabled)
1119  tool.setColumn (outputColumns.at(0).name, offsets.size(), offsets.data());
1120  if (outputColumns.at(1).enabled)
1121  tool.setColumn (outputColumns.at(1).name, namesData.size(), namesData.data());
1122  if (outputColumns.at(2).enabled)
1123  tool.setColumn (outputColumns.at(2).name, namesOffsets.size(), namesOffsets.data());
1124  if (outputColumns.at(3).enabled)
1125  tool.setColumn (outputColumns.at(3).name, namesHash.size(), namesHash.data());
1126  }
1127  };
1128 
1130  {
1132  std::vector<ColumnarOffsetType> offsets = {0};
1133  std::vector<std::uint32_t> columnData;
1134  Benchmark benchmarkUnpack;
1135  Benchmark benchmark;
1136 
1137  ColumnDataSamplingPattern (const std::string& val_branchName)
1138  : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+".samplingPattern(fallback)(unpack)"), benchmark (branchReader.columnName() + ".samplingPattern(fallback)")
1139  {
1140  outputColumns.push_back ({.name = branchReader.columnName() + ".samplingPattern"});
1141  outputColumns.push_back ({.name = branchReader.columnName(), .isOffset = true, .primary = false});
1142  }
1143 
1144  virtual bool connect (TTree *tree, std::unordered_map<std::string,const std::vector<ColumnarOffsetType>*>& /*offsetColumns*/, std::unordered_map<std::string,ColumnInfo>& requestedColumns) override
1145  {
1146  auto iter = requestedColumns.find (outputColumns.at(0).name);
1147  if (iter == requestedColumns.end())
1148  return false;
1149  outputColumns.at(0).enabled = true;
1150 
1151  branchReader.connectTree (tree);
1152 
1153  if (iter->second.offsetName != outputColumns.at(1).name)
1154  throw std::runtime_error ("offset name mismatch: " + iter->second.offsetName + " != " + outputColumns.at(1).name);
1155 
1156  requestedColumns.erase (iter);
1157 
1158  iter = requestedColumns.find (outputColumns.at(1).name);
1159  if (iter == requestedColumns.end())
1160  {
1161  return true;
1162  }
1163  outputColumns.at(1).enabled = true;
1164  requestedColumns.erase (iter);
1165  return true;
1166  }
1167 
1168  virtual void clearColumns () override
1169  {
1170  columnData.clear();
1171  offsets.clear();
1172  offsets.push_back (0);
1173  }
1174 
1175  virtual void getEntry (Long64_t entry) override
1176  {
1177  benchmark.startTimer ();
1178  const auto& branchData = branchReader.getEntry (entry);
1179  benchmark.stopTimer ();
1180  benchmarkUnpack.startTimer ();
1181  for (auto data : branchData)
1182  {
1183  columnData.push_back (data->samplingPattern());
1184  }
1185  offsets.push_back (columnData.size());
1186  benchmarkUnpack.stopTimer ();
1187  }
1188 
1189  virtual void setData (ColumnarToolWrapperData& tool) override
1190  {
1191  if (outputColumns.at(0).enabled)
1192  tool.setColumn (outputColumns.at(0).name, columnData.size(), columnData.data());
1193  if (outputColumns.at(1).enabled)
1194  tool.setColumn (outputColumns.at(1).name, offsets.size(), offsets.data());
1195  }
1196  };
1197  }
1198 
1199 
1202  {
1203  static std::once_flag flag;
1204  std::call_once (flag, [] ()
1205  {
1206 #ifdef XAOD_STANDALONE
1207  xAOD::Init().ignore();
1208 #else
1209  POOL::Init();
1210 #endif
1211  });
1212 
1213  auto *fileName = getenv ("ASG_TEST_FILE_LITE_MC");
1214  if (fileName == nullptr)
1215  throw std::runtime_error ("missing ASG_TEST_FILE_LITE_MC");
1216  file.reset (TFile::Open (fileName, "READ"));
1217  if (!file)
1218  throw std::runtime_error ("failed to open file");
1219  tree = dynamic_cast<TTree*> (file->Get ("CollectionTree"));
1220  if (!tree)
1221  throw std::runtime_error ("failed to open tree");
1222  }
1223 
1225 
1227  {
1228  static std::atomic<unsigned> index = 0;
1229  return "UniquePhysliteTestTool" + std::to_string(++index);
1230  }
1231 
1233  checkMode ()
1234  {
1235  return true;
1236  }
1237 
1239  {
1240  using namespace PhysliteTestHelpers;
1241 
1242  knownColumns.push_back (std::make_shared<ColumnDataEventCount> ());
1243 
1244  {
1245  std::unordered_map<std::string,TBranch*> branches;
1246  {
1247  TIter branchIter (tree->GetListOfBranches());
1248  TObject *obj = nullptr;
1249  while ((obj = branchIter()))
1250  {
1251  TBranch *branch = nullptr;
1252  if ((branch = dynamic_cast<TBranch*>(obj)))
1253  {
1254  branches.emplace (branch->GetName(), branch);
1255  TIter subBranchIter (branch->GetListOfBranches());
1256  while ((obj = subBranchIter()))
1257  {
1258  if (auto subBranch = dynamic_cast<TBranch*>(obj))
1259  branches.emplace (subBranch->GetName(), subBranch);
1260  }
1261  }
1262  }
1263  }
1264 
1265  for (const auto& [name, branch] : branches)
1266  {
1267  if (name.find ("AuxDyn.") != std::string::npos ||
1268  name.find ("Aux.") != std::string::npos)
1269  {
1270  TClass *branchClass = nullptr;
1271  EDataType branchType {};
1272  branch->GetExpectedType (branchClass, branchType);
1273  if (branchClass == nullptr)
1274  {
1275  switch (branchType)
1276  {
1277  case kInt_t:
1278  knownColumns.push_back (std::make_shared<ColumnDataScalar<std::int32_t>> (branch->GetName()));
1279  break;
1280  case kUInt_t:
1281  knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint32_t>> (branch->GetName()));
1282  break;
1283  case kULong_t:
1284  knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint64_t>> (branch->GetName()));
1285  break;
1286  case kULong64_t:
1287  knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint64_t>> (branch->GetName()));
1288  break;
1289  case kFloat_t:
1290  knownColumns.push_back (std::make_shared<ColumnDataScalar<float>> (branch->GetName()));
1291  break;
1292  default:
1293  // no-op
1294  break;
1295  }
1296  } else
1297  {
1298  if (*branchClass->GetTypeInfo() == typeid(std::vector<float>))
1299  {
1300  knownColumns.push_back (std::make_shared<ColumnDataVector<float>> (branch->GetName()));
1301  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<char>))
1302  {
1303  knownColumns.push_back (std::make_shared<ColumnDataVector<char>> (branch->GetName()));
1304  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int8_t>))
1305  {
1306  knownColumns.push_back (std::make_shared<ColumnDataVector<std::int8_t>> (branch->GetName()));
1307  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint8_t>))
1308  {
1309  knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint8_t>> (branch->GetName()));
1310  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int16_t>))
1311  {
1312  knownColumns.push_back (std::make_shared<ColumnDataVector<std::int16_t>> (branch->GetName()));
1313  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint16_t>))
1314  {
1315  knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint16_t>> (branch->GetName()));
1316  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int32_t>))
1317  {
1318  knownColumns.push_back (std::make_shared<ColumnDataVector<std::int32_t>> (branch->GetName()));
1319  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint32_t>))
1320  {
1321  knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint32_t>> (branch->GetName()));
1322  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::int64_t>))
1323  {
1324  knownColumns.push_back (std::make_shared<ColumnDataVector<std::int64_t>> (branch->GetName()));
1325  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::uint64_t>))
1326  {
1327  knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint64_t>> (branch->GetName()));
1328  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<float>>))
1329  {
1330  knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> (branch->GetName()));
1331  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::int32_t>>))
1332  {
1333  knownColumns.push_back (std::make_shared<ColumnDataVectorVector<std::int32_t>> (branch->GetName()));
1334  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::uint64_t>>))
1335  {
1336  knownColumns.push_back (std::make_shared<ColumnDataVectorVector<std::uint64_t>> (branch->GetName()));
1337  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::vector<std::size_t>>>))
1338  {
1339  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVector<std::size_t>> (branch->GetName()));
1340  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::vector<std::vector<unsigned char>>>))
1341  {
1342  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVector<unsigned char>> (branch->GetName()));
1343  } else if (*branchClass->GetTypeInfo() == typeid(std::vector<std::string>))
1344  {
1345  knownColumns.push_back (std::make_shared<ColumnDataMetNames> (branch->GetName()));
1346  }
1347  }
1348  }
1349  }
1350  }
1351 
1352  // This is a fallback for the case that we don't have an explicit
1353  // `samplingPattern` branch in our input file (i.e. an older file),
1354  // to allow us to still test tools needing it. This is likely not
1355  // something that actual users can do (they need the new files), but
1356  // for testing it seems like a reasonable workaround.
1357  knownColumns.push_back (std::make_shared<ColumnDataSamplingPattern> ("egammaClusters"));
1358 
1359  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::CaloClusterContainer>> ("AnalysisElectronsAuxDyn.caloClusterLinks"));
1360 
1361  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::TrackParticleContainer>> ("GSFConversionVerticesAuxDyn.trackParticleLinks"));
1362 
1363  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisElectrons.ptOut", 0));
1364  knownColumns.push_back (std::make_shared<ColumnDataOutVector<std::uint16_t>> ("AnalysisElectrons.ptRank", 0));
1365  knownColumns.push_back (std::make_shared<ColumnDataOutVector<std::uint16_t>> ("AnalysisElectrons.etaRank", 0));
1366 
1367  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisElectrons.sfOut", 0));
1368  knownColumns.push_back (std::make_shared<ColumnDataOutVector<char>> ("AnalysisElectrons.validOut", 0));
1369 
1370  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::CaloClusterContainer>> ("AnalysisPhotonsAuxDyn.caloClusterLinks"));
1371  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::VertexContainer>> ("AnalysisPhotonsAuxDyn.vertexLinks"));
1372 
1373  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisPhotons.sfOut", 0));
1374  knownColumns.push_back (std::make_shared<ColumnDataOutVector<char>> ("AnalysisPhotons.validOut", 0));
1375  knownColumns.push_back (std::make_shared<ColumnDataOutVector<char>> ("AnalysisPhotons.selection", 0));
1376 
1377  knownColumns.push_back (std::make_shared<ColumnDataOutVector<std::uint16_t>> ("AnalysisMuons.objectType", xAOD::Type::Muon));
1378  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.m", 0));
1379  knownColumns.push_back (std::make_shared<ColumnDataOutVector<std::uint16_t>> ("AnalysisMuons.ptRank", 0));
1380 
1381  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.ptOut", 0));
1382  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.chargeOut", 0));
1383  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.InnerDetectorCharge", 0));
1384  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.InnerDetectorPt", 0));
1385  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.MuonSpectrometerCharge", 0));
1386  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.MuonSpectrometerPt", 0));
1387  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.sfOut", 0));
1388  knownColumns.push_back (std::make_shared<ColumnDataOutVector<char>> ("AnalysisMuons.validOut", 0));
1389  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisMuons.MetObjectWeight", 0));
1390 
1391  knownColumns.push_back (std::make_shared<ColumnDataOutVector<std::uint16_t>> ("AnalysisJets.objectType", xAOD::Type::Jet));
1392 
1393  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisJets.ptOut", 0));
1394  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisJets.mOut", 0));
1395  knownColumns.push_back (std::make_shared<ColumnDataOutVector<char>> ("AnalysisJets.selection", 0));
1396  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisJets.MetObjectWeight", 0));
1397  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("AnalysisJets.MetObjectWeightSoft", 0));
1398 
1399  knownColumns.push_back (std::make_shared<ColumnDataVectorLink<xAOD::TrackParticleContainer>> ("AnalysisMuonsAuxDyn.inDetTrackParticleLink"));
1400  knownColumns.push_back (std::make_shared<ColumnDataVectorLink<xAOD::TrackParticleContainer>> ("AnalysisMuonsAuxDyn.combinedTrackParticleLink"));
1401  knownColumns.push_back (std::make_shared<ColumnDataVectorLink<xAOD::TrackParticleContainer>> ("AnalysisMuonsAuxDyn.extrapolatedMuonSpectrometerTrackParticleLink"));
1402 
1403  knownColumns.push_back (std::make_shared<ColumnDataOutputMet> ("OutputMET", std::vector<std::string>{"Muons", "RefJet", "MuonEloss", "PVSoftTrk"}));
1404  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("OutputMET.mpx", 0));
1405  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("OutputMET.mpy", 0));
1406  knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> ("OutputMET.sumet", 0));
1407  knownColumns.push_back (std::make_shared<ColumnDataOutVector<std::uint64_t>> ("OutputMET.source", 0));
1408 
1409  knownColumns.push_back (std::make_shared<ColumnDataVectorLink<xAOD::JetContainer>>("METAssoc_AnalysisMETAux.jetLink"));
1410  knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVariantLink<xAOD::IParticleContainer>>("METAssoc_AnalysisMETAux.objectLinks"));
1411 
1412  knownColumns.push_back (std::make_shared<ColumnDataOutVector<MissingETBase::Types::bitmask_t>> ("METAssoc_AnalysisMET.useObjectFlags", 0));
1413  }
1414 
1416  {
1417  std::unordered_map<std::string,ColumnInfo> requestedColumns;
1418  for (auto& column : toolWrapper.getColumnInfo())
1419  requestedColumns[column.name] = std::move (column);
1420 
1421  for (auto& name : toolWrapper.getColumnNames())
1422  std::cout << "requested columns: " << name << std::endl;
1423 
1424  for (auto& column : knownColumns)
1425  {
1426  if (column->connect (tree, offsetColumns, requestedColumns))
1427  usedColumns.push_back (column);
1428  }
1429 
1430  std::set<std::string> unclaimedColumns;
1431  for (auto& column : requestedColumns)
1432  {
1433  if (!column.second.isOptional)
1434  unclaimedColumns.insert (column.first);
1435  else
1436  std::cout << "optional column not claimed: " << column.first << std::endl;
1437  }
1438  if (!unclaimedColumns.empty())
1439  {
1440  std::string message = "columns not claimed:";
1441  for (auto& column : unclaimedColumns)
1442  message += " " + column;
1443  throw std::runtime_error (message);
1444  }
1445  }
1446 
1447  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)
1448  {
1449  using namespace asg::msgUserCode;
1450 
1451  if (!sysName.empty())
1452  {
1453  auto *sysTool = dynamic_cast<CP::ISystematicsTool*>(&tool);
1454  if (!sysTool)
1455  throw std::runtime_error ("tool does not support systematics");
1456  std::cout << "applying systematic variation: " << sysName << std::endl;
1457  if (sysTool->applySystematicVariation (CP::SystematicSet (sysName)).isFailure())
1458  throw std::runtime_error ("failed to apply systematic variation: " + sysName);
1459  }
1460  if constexpr (columnarAccessMode == 2)
1461  {
1462  auto *myTool = dynamic_cast<ColumnarTool<ColumnarModeArray>*>(&tool);
1463  if (!containerRenames.empty())
1464  renameContainers (*myTool, containerRenames);
1465  ColumnarToolWrapper toolWrapper (myTool);
1466 
1467  setupKnownColumns ();
1468  setupColumns (toolWrapper);
1469 
1470  Benchmark benchmark (name);
1471 
1472  const std::vector<ColumnarOffsetType>* offsetColumn = nullptr;
1473  if (!container.empty())
1474  {
1475  auto iter = offsetColumns.find (container);
1476  if (iter == offsetColumns.end())
1477  throw std::runtime_error ("missing size column: " + container);
1478  offsetColumn = iter->second;
1479  }
1480 
1481  const auto numberOfEvents = tree->GetEntries();
1483  Long64_t entry = 0;
1484  for (; benchmark.getTotalTime() < targetTime; ++entry)
1485  {
1486  ColumnarToolWrapperData columnData (&toolWrapper);
1487  for (auto& column : usedColumns)
1488  column->getEntry (entry % numberOfEvents);
1489  if (offsetColumn)
1490  {
1491  if (entry + 1 == numberOfEvents)
1492  std::cout << "average size: " << float (totalSize + offsetColumn->back()) / numberOfEvents << std::endl;
1493  }
1494  if ((entry + 1) % batchSize == 0)
1495  {
1496  if (offsetColumn)
1497  totalSize += offsetColumn->back();
1498  for (auto& column : usedColumns)
1499  column->setData (columnData);
1500  benchmark.startTimer ();
1501  columnData.call ();
1502  benchmark.stopTimer ();
1503  for (auto& column : usedColumns)
1504  column->clearColumns ();
1505  }
1506  }
1507  std::cout << "Total entries read: " << entry << std::endl;
1508  } else if constexpr (columnarAccessMode == 0)
1509  {
1510  // this test simply doesn't work in Athena
1511 #ifdef XAOD_STANDALONE
1514 #else
1516 #endif
1517  ANA_CHECK_THROW (event.readFrom (file.get()));
1518 
1519 #ifdef XAOD_STANDALONE
1520  Benchmark benchmarkEmptyClear (name + " empty clear");
1521  Benchmark benchmarkCallClear (name + " call clear");
1522  Benchmark benchmarkPrepClear (name + " prep clear");
1523 #endif
1524  Benchmark benchmarkCall (name + " call");
1525  Benchmark benchmarkPrep (name + " prep");
1526  Benchmark benchmarkGetEntry (name + " getEntry");
1527 
1528  const auto numberOfEvents = event.getEntries();
1529  if (numberOfEvents == 0){
1530  throw std::runtime_error ("ColumnarPhysLiteTest: numberOfEvents == 0");
1531  }
1532  Long64_t entry = 0;
1533 
1534  // Instead of running for a fixed number of events, we run for a
1535  // fixed amount of time. That is because individual tools can
1536  // vary wildly in how long they take to run, and we mostly want to
1537  // make sure that we ran the tool enough to get a precise
1538  // performance estimate. As a fail-safe it also bounds the time
1539  // spend in i/o, which can be significant in Athena, but at a much
1540  // higher level.
1541  for (; benchmarkCall.getTotalTime() < targetTime && benchmarkPrep.getTotalTime() + benchmarkGetEntry.getTotalTime() < 20 * targetTime; ++entry)
1542  {
1543  benchmarkGetEntry.startTimer ();
1544  event.getEntry (entry % numberOfEvents);
1545  benchmarkGetEntry.stopTimer ();
1546  XAODArgs args;
1547  args.inputContainer = container;
1548  args.outputContainer = container + "Copy1";
1549  args.isPrepCall = true;
1550  benchmarkPrep.startTimer ();
1551  callXAOD (args);
1552  benchmarkPrep.stopTimer ();
1553  args.outputContainer = container + "Copy2";
1554  args.isPrepCall = false;
1555 #ifdef XAOD_STANDALONE
1556  benchmarkPrepClear.startTimer ();
1557  store.clear ();
1558  benchmarkPrepClear.stopTimer ();
1559 #endif
1560  benchmarkCall.startTimer ();
1561  callXAOD (args);
1562  benchmarkCall.stopTimer ();
1563 #ifdef XAOD_STANDALONE
1564  benchmarkCallClear.startTimer ();
1565  store.clear ();
1566  benchmarkCallClear.stopTimer ();
1567  benchmarkEmptyClear.startTimer ();
1568  store.clear ();
1569  benchmarkEmptyClear.stopTimer ();
1570 #endif
1571  }
1572  std::cout << "Total entries read: " << entry << std::endl;
1573  }
1574  }
1575 }
columnar::PhysliteTestHelpers::ColumnDataOutVector::outData
std::vector< T > outData
Definition: ColumnarPhysliteTest.cxx:382
CaloCondBlobAlgs_fillNoiseFromASCII.sysName
sysName
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:92
columnar::PhysliteTestHelpers::ColumnDataVectorVector::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:467
columnar::PhysliteTestHelpers::ColumnDataOutVector::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:422
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:975
SGTest::store
TestStore store
Definition: TestStore.cxx:23
columnar::PhysliteTestHelpers::ColumnDataVector::benchmarkUnpack
Benchmark benchmarkUnpack
Definition: ColumnarPhysliteTest.cxx:304
columnar::PhysliteTestHelpers::ColumnDataVector::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:343
columnar::PhysliteTestHelpers::ColumnDataMetNames::columnHashData
std::vector< std::size_t > columnHashData
Definition: ColumnarPhysliteTest.cxx:963
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:176
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:361
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:965
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::branchReader
BranchReader< std::vector< std::vector< std::vector< T > > > > branchReader
Definition: ColumnarPhysliteTest.cxx:604
columnar::PhysliteTestHelpers::ColumnDataEventCount
Definition: ColumnarPhysliteTest.cxx:211
columnar::PhysliteTestHelpers::ColumnDataEventCount::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:230
vtune_athena.format
format
Definition: vtune_athena.py:14
python.CaloAddPedShiftConfig.args
args
Definition: CaloAddPedShiftConfig.py:47
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::ColumnDataVectorVectorVector
ColumnDataVectorVectorVector(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:611
columnar::PhysliteTestHelpers::ColumnDataOutputMet::namesHash
std::vector< std::size_t > namesHash
Definition: ColumnarPhysliteTest.cxx:1047
columnar::PhysliteTestHelpers::BranchReader::~BranchReader
~BranchReader() noexcept
Definition: ColumnarPhysliteTest.cxx:132
index
Definition: index.py:1
columnar::ColumnarPhysLiteTest::setupColumns
void setupColumns(ColumnarToolWrapper &toolWrapper)
Definition: ColumnarPhysliteTest.cxx:1415
columnar::PhysliteTestHelpers::ColumnDataOutputMet::getEntry
virtual void getEntry(Long64_t) override
Definition: ColumnarPhysliteTest.cxx:1105
columnar::PhysliteTestHelpers::BranchReader::columnName
std::string columnName() const
Definition: ColumnarPhysliteTest.cxx:140
m_count
std::uint64_t m_count
the number of times the timer has been started
Definition: ColumnarPhysliteTest.cxx:70
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:619
columnar::PhysliteTestHelpers::ColumnDataVector::branchReader
BranchReader< std::vector< T > > branchReader
Definition: ColumnarPhysliteTest.cxx:300
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:253
m_ticks
std::chrono::high_resolution_clock::duration m_ticks
accumulated time m_ticks
Definition: ColumnarPhysliteTest.cxx:67
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:488
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::benchmarkUnpack
Benchmark benchmarkUnpack
Definition: ColumnarPhysliteTest.cxx:1134
DeMoUpdate.column
dictionary column
Definition: DeMoUpdate.py:1110
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::branchReader
BranchReader< xAOD::CaloClusterContainer > branchReader
Definition: ColumnarPhysliteTest.cxx:1131
columnar::ColumnarPhysLiteTest::~ColumnarPhysLiteTest
~ColumnarPhysLiteTest()
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::benchmark
Benchmark benchmark
Definition: ColumnarPhysliteTest.cxx:609
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:390
columnar::ColumnarPhysLiteTest::ColumnarPhysLiteTest
ColumnarPhysLiteTest()
Definition: ColumnarPhysliteTest.cxx:1201
columnar::PhysliteTestHelpers::IColumnData::OutputColumnInfo
Definition: ColumnarPhysliteTest.cxx:191
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:560
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:1189
m_name
std::string m_name
Definition: ColumnarPhysliteTest.cxx:62
columnar::PhysliteTestHelpers::BranchReader::connectTree
void connectTree(TTree *tree)
Definition: ColumnarPhysliteTest.cxx:164
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:678
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:445
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
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:1135
columnar::PhysliteTestHelpers::ColumnDataOutputMet::ColumnDataOutputMet
ColumnDataOutputMet(const std::string &val_columnName, std::vector< std::string > val_termNames)
Definition: ColumnarPhysliteTest.cxx:1049
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:119
runLayerRecalibration.branches
list branches
Definition: runLayerRecalibration.py:98
columnar::PhysliteTestHelpers::ColumnDataScalar::getEntry
virtual void getEntry(Long64_t entry) override
Definition: ColumnarPhysliteTest.cxx:280
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::columnData
std::vector< T > columnData
Definition: ColumnarPhysliteTest.cxx:607
columnar::columnarAccessMode
constexpr unsigned columnarAccessMode
Definition: ColumnarDef.h:12
columnar::PhysliteTestHelpers::ColumnDataMetNames::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:1029
columnar::PhysliteTestHelpers::ColumnDataVector::ColumnDataVector
ColumnDataVector(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:307
columnar::ColumnInfo
a struct that contains meta-information about each column that's needed to interface the column with ...
Definition: ColumnInfo.h:35
python.handimod.now
now
Definition: handimod.py:674
columnar::PhysliteTestHelpers::ColumnDataMetNames::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:1006
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:962
columnar::PhysliteTestHelpers::ColumnDataMetNames
Definition: ColumnarPhysliteTest.cxx:959
columnar::PhysliteTestHelpers::ColumnDataVector::benchmark
Benchmark benchmark
Definition: ColumnarPhysliteTest.cxx:305
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::getEntry
virtual void getEntry(Long64_t entry) override
Definition: ColumnarPhysliteTest.cxx:660
StateLessPT_NewConfig.primary
primary
Definition: StateLessPT_NewConfig.py:234
columnar::PhysliteTestHelpers::ColumnDataOutVector::getEntry
virtual void getEntry(Long64_t) override
Definition: ColumnarPhysliteTest.cxx:417
columnar::PhysliteTestHelpers::ColumnDataVectorVector
Definition: ColumnarPhysliteTest.cxx:431
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
columnar::PhysliteTestHelpers::ColumnDataOutVector::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:412
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:1133
IColumnarTool.h
lumiFormat.i
int i
Definition: lumiFormat.py:85
columnar::PhysliteTestHelpers::ColumnDataOutputMet::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:1116
columnar::PhysliteTestHelpers::ColumnDataOutputMet::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:1095
vector
Definition: MultiHisto.h:13
columnar::ColumnarPhysLiteTest::makeUniqueName
std::string makeUniqueName()
make a unique tool name to be used in unit tests
Definition: ColumnarPhysliteTest.cxx:1226
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:380
file
TFile * file
Definition: tile_monitor.h:29
columnar::PhysliteTestHelpers::ColumnDataScalar::benchmarkUnpack
Benchmark benchmarkUnpack
Definition: ColumnarPhysliteTest.cxx:252
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:651
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
columnar::PhysliteTestHelpers::ColumnDataVectorVector::ColumnDataVectorVector
ColumnDataVectorVector(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:438
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:1058
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:290
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:64
columnar::PhysliteTestHelpers::BranchReader::m_isStatic
bool m_isStatic
Definition: ColumnarPhysliteTest.cxx:121
columnar::PhysliteTestHelpers::BranchReader::m_data
T * m_data
Definition: ColumnarPhysliteTest.cxx:122
columnar::PhysliteTestHelpers::BranchReader::containerName
std::string containerName() const
Definition: ColumnarPhysliteTest.cxx:152
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector::benchmarkUnpack
Benchmark benchmarkUnpack
Definition: ColumnarPhysliteTest.cxx:608
columnar::final
CM final
Definition: ColumnAccessor.h:106
PixelAthHitMonAlgCfg.duration
duration
Definition: PixelAthHitMonAlgCfg.py:152
columnar::ColumnarPhysLiteTest::setupKnownColumns
void setupKnownColumns()
Definition: ColumnarPhysliteTest.cxx:1238
MissingETBase.h
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern
Definition: ColumnarPhysliteTest.cxx:1130
columnar::PhysliteTestHelpers::IColumnData::setData
virtual void setData(ColumnarToolWrapperData &tool)=0
columnar::PhysliteTestHelpers::ColumnDataVector
Definition: ColumnarPhysliteTest.cxx:299
columnar::PhysliteTestHelpers::ColumnDataOutputMet::namesData
std::vector< char > namesData
Definition: ColumnarPhysliteTest.cxx:1046
columnar::PhysliteTestHelpers::ColumnDataVector::getEntry
virtual void getEntry(Long64_t entry) override
Definition: ColumnarPhysliteTest.cxx:350
columnar::PhysliteTestHelpers::ColumnDataEventCount::setData
virtual void setData(ColumnarToolWrapperData &tool) override
Definition: ColumnarPhysliteTest.cxx:241
columnar::PhysliteTestHelpers::ColumnDataVectorVectorVector
Definition: ColumnarPhysliteTest.cxx:602
columnar::PhysliteTestHelpers::IColumnData::outputColumns
std::vector< OutputColumnInfo > outputColumns
Definition: ColumnarPhysliteTest.cxx:197
ColumnarToolWrapper.h
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
columnar::PhysliteTestHelpers::ColumnDataVectorVector::benchmark
Benchmark benchmark
Definition: ColumnarPhysliteTest.cxx:436
columnar::PhysliteTestHelpers::ColumnDataScalar::outData
std::vector< T > outData
Definition: ColumnarPhysliteTest.cxx:254
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:1014
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:193
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:303
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:1447
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
columnar::PhysliteTestHelpers::ColumnDataVectorVector::branchReader
BranchReader< std::vector< std::vector< T > > > branchReader
Definition: ColumnarPhysliteTest.cxx:432
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:214
columnar::PhysliteTestHelpers::ColumnDataOutputMet
Definition: ColumnarPhysliteTest.cxx:1041
columnar::PhysliteTestHelpers::IColumnData::OutputColumnInfo::enabled
bool enabled
Definition: ColumnarPhysliteTest.cxx:195
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:194
RTTAlgmain.branch
branch
Definition: RTTAlgmain.py:61
columnar::PhysliteTestHelpers::ColumnDataMetNames::benchmarkUnpack
Benchmark benchmarkUnpack
Definition: ColumnarPhysliteTest.cxx:964
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:314
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:1233
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:1168
columnar::PhysliteTestHelpers::ColumnDataOutVector::ColumnDataOutVector
ColumnDataOutVector(const std::string &val_columnName, const T &val_defaultValue)
Definition: ColumnarPhysliteTest.cxx:384
SCT_ConditionsAlgorithms::CoveritySafe::getenv
std::string getenv(const std::string &variableName)
get an environment variable
Definition: SCT_ConditionsUtilities.cxx:17
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:1144
columnar::PhysliteTestHelpers::ColumnDataEventCount::getEntry
virtual void getEntry(Long64_t) override
Definition: ColumnarPhysliteTest.cxx:236
columnar::ColumnarTool
the base class for all columnar components
Definition: ColumnAccessorDataArray.h:17
columnar::PhysliteTestHelpers::BranchReader::m_branch
TBranch * m_branch
Definition: ColumnarPhysliteTest.cxx:120
columnar::PhysliteTestHelpers::ColumnDataScalar
Definition: ColumnarPhysliteTest.cxx:250
columnar::PhysliteTestHelpers::ColumnDataScalar::clearColumns
virtual void clearColumns() override
Definition: ColumnarPhysliteTest.cxx:275
columnar::PhysliteTestHelpers::IColumnData::OutputColumnInfo::name
std::string name
Definition: ColumnarPhysliteTest.cxx:192
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:262
CaloClusterContainer.h
ColumnarToolHelpers.h
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::ColumnDataSamplingPattern
ColumnDataSamplingPattern(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:1137
python.copyTCTOutput.totalSize
totalSize
Definition: copyTCTOutput.py:92
columnar::PhysliteTestHelpers::ColumnDataMetNames::ColumnDataMetNames
ColumnDataMetNames(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:967
jobOptions.fileName
fileName
Definition: jobOptions.SuperChic_ALP2.py:39
ColumnInfo.h
columnar::PhysliteTestHelpers::ColumnDataVectorVector::columnData
std::vector< T > columnData
Definition: ColumnarPhysliteTest.cxx:434
columnar::PhysliteTestHelpers::ColumnDataScalar::ColumnDataScalar
ColumnDataScalar(const std::string &val_branchName)
Definition: ColumnarPhysliteTest.cxx:256
columnar::PhysliteTestHelpers::BranchReader
Definition: ColumnarPhysliteTest.cxx:118
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:603
columnar::PhysliteTestHelpers::ColumnDataVectorVector::getEntry
virtual void getEntry(Long64_t entry) override
Definition: ColumnarPhysliteTest.cxx:474
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:379
columnar::PhysliteTestHelpers::ColumnDataSamplingPattern::getEntry
virtual void getEntry(Long64_t entry) override
Definition: ColumnarPhysliteTest.cxx:1175
columnar::PhysliteTestHelpers::ColumnDataMetNames::branchReader
BranchReader< std::vector< std::string > > branchReader
Definition: ColumnarPhysliteTest.cxx:960
columnar::PhysliteTestHelpers::ColumnDataOutputMet::termNames
std::vector< std::string > termNames
Definition: ColumnarPhysliteTest.cxx:1042
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:125
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:435
columnar::PhysliteTestHelpers::IColumnData
Definition: ColumnarPhysliteTest.cxx:187
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:251
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:219
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37