30 #ifndef XAOD_STANDALONE
43 #include <gtest/gtest.h>
57 const unsigned int batchSize = 1000;
64 std::chrono::time_point<std::chrono::high_resolution_clock>
m_start;
73 Benchmark (
const std::string& val_name)
80 std::cout <<
m_name <<
": " << std::chrono::duration<std::uint64_t,std::nano> (
m_ticks) /
m_count << std::endl;
83 auto getTotalTime ()
const
101 namespace PhysliteTestHelpers
105 static const std::unordered_map<std::string,SG::sgkey_t> knownKeys =
107 {
"AnalysisMuons", 0x3a6b126f},
108 {
"AnalysisElectrons", 0x3902fec0},
109 {
"AnalysisPhotons", 0x35d1472f},
110 {
"AnalysisJets", 0x1afd1919},
111 {
"egammaClusters", 0x15788d1f},
112 {
"InDetTrackParticles", 0x2e42db0b},
113 {
"GSFConversionVertices", 0x1f3e85c9}
147 else if (
columnName.find (
".") != std::string::npos)
148 throw std::runtime_error (
"branch name does not contain AuxDyn or Aux: " +
m_branchName);
161 throw std::runtime_error (
"branch name does not contain AuxDyn or Aux: " +
m_branchName);
168 throw std::runtime_error (
"failed to get branch: " +
m_branchName);
179 throw std::runtime_error (
"branch not connected: " +
m_branchName);
212 std::array<ColumnarOffsetType, 2>
data = {0, 0};
219 virtual bool connect (TTree * , std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& , std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
257 : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+
"(unpack)"), benchmark (branchReader.columnName())
262 virtual bool connect (TTree *
tree, std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& , std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
265 if (
iter == requestedColumns.end())
268 requestedColumns.erase (
iter);
282 benchmark.startTimer ();
284 benchmark.stopTimer ();
285 benchmarkUnpack.startTimer ();
286 outData.push_back (branchData);
287 benchmarkUnpack.stopTimer ();
301 const std::vector<ColumnarOffsetType>* offsetColumn =
nullptr;
302 std::vector<ColumnarOffsetType> offsets = {0};
308 : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+
"(unpack)"), benchmark (branchReader.columnName())
314 virtual bool connect (TTree *
tree, std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
317 if (
iter == requestedColumns.end())
324 throw std::runtime_error (
"offset name mismatch: " +
iter->second.offsetName +
" != " +
outputColumns.at(1).name);
326 requestedColumns.erase (
iter);
328 if (
auto offsetIter = offsetColumns.find (
outputColumns.at(1).name); offsetIter != offsetColumns.end())
329 offsetColumn = offsetIter->second;
334 if (
iter != requestedColumns.end())
336 requestedColumns.erase (
iter);
346 offsets.push_back (0);
352 benchmark.startTimer ();
354 benchmark.stopTimer ();
355 benchmarkUnpack.startTimer ();
356 outData.insert (outData.end(), branchData.begin(), branchData.end());
357 offsets.push_back (outData.size());
358 benchmarkUnpack.stopTimer ();
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);
381 const std::vector<ColumnarOffsetType>* offsetColumn =
nullptr;
385 : defaultValue (val_defaultValue)
390 virtual bool connect (TTree * , std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
393 if (
iter == requestedColumns.end())
399 const auto offsetName =
iter->second.offsetName;
400 if (offsetName.empty())
401 throw std::runtime_error (
"missing offset column for: " +
outputColumns.at(0).name);
403 requestedColumns.erase (
iter);
405 if (
auto offsetIter = offsetColumns.find (offsetName); offsetIter != offsetColumns.end())
406 offsetColumn = offsetIter->second;
408 throw std::runtime_error (
"missing offset column for: " +
outputColumns.at(0).name);
419 outData.resize (offsetColumn->back(), defaultValue);
433 std::vector<ColumnarOffsetType> offsets = {0};
439 : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+
"(unpack)"), benchmark (branchReader.columnName())
445 virtual bool connect (TTree *
tree, std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& , std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
448 if (
iter == requestedColumns.end())
455 throw std::runtime_error (
"offset name mismatch: " +
iter->second.offsetName +
" != " +
outputColumns.at(1).name);
457 requestedColumns.erase (
iter);
460 if (
iter == requestedColumns.end())
462 requestedColumns.erase (
iter);
471 offsets.push_back (0);
476 benchmark.startTimer ();
478 benchmark.stopTimer ();
479 benchmarkUnpack.startTimer ();
480 for (
auto&
data : branchData)
482 columnData.insert (columnData.end(),
data.begin(),
data.end());
483 offsets.push_back (columnData.size());
485 benchmarkUnpack.stopTimer ();
501 std::vector<ColumnarOffsetType> offsets = {0};
503 const std::vector<ColumnarOffsetType>* targetOffsetColumn =
nullptr;
510 : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+
"(unpack)"), benchmark (branchReader.columnName())
516 virtual bool connect (TTree *
tree, std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
519 if (
iter == requestedColumns.end())
526 throw std::runtime_error (
"offset name mismatch: " +
iter->second.offsetName +
" != " +
outputColumns.at(1).name);
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;
534 throw std::runtime_error (
"missing offset column: " +
iter->second.linkToName);
536 requestedColumns.erase (
iter);
539 if (
iter == requestedColumns.end())
541 requestedColumns.erase (
iter);
550 offsets.push_back (0);
555 benchmark.startTimer ();
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)
563 for (
auto& element :
data)
565 if (element.isDefault() || (element.key() == 0 && element.index() == 0))
569 columnData.push_back (element.index() + targetOffsetColumn->at (targetOffsetColumn->size()-2));
570 if (element.key() != targetKey)
574 targetKey = element.key();
575 std::cout <<
"assume target key for " << targetContainerName <<
" is " << std::hex << targetKey << std::dec << std::endl;
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())
586 offsets.push_back (columnData.size());
588 benchmarkUnpack.stopTimer ();
605 std::vector<ColumnarOffsetType> outerOffsets = {0};
606 std::vector<ColumnarOffsetType> innerOffsets = {0};
612 : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+
"(unpack)"), benchmark (branchReader.columnName())
619 virtual bool connect (TTree *
tree, std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& , std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
622 if (
iter == requestedColumns.end())
629 throw std::runtime_error (
"offset name mismatch: " +
iter->second.offsetName +
" != " +
outputColumns.at(1).name);
631 requestedColumns.erase (
iter);
634 if (
iter == requestedColumns.end())
639 throw std::runtime_error (
"offset name mismatch: " +
iter->second.offsetName +
" != " +
outputColumns.at(2).name);
641 requestedColumns.erase (
iter);
644 if (
iter == requestedColumns.end())
647 requestedColumns.erase (
iter);
654 innerOffsets.clear();
655 innerOffsets.push_back (0);
656 outerOffsets.clear();
657 outerOffsets.push_back (0);
662 benchmark.startTimer ();
664 benchmark.stopTimer ();
665 benchmarkUnpack.startTimer ();
666 for (
auto& outerData : branchData)
668 for (
auto& innerData : outerData)
670 columnData.insert (columnData.end(), innerData.begin(), innerData.end());
671 innerOffsets.push_back (columnData.size());
673 outerOffsets.push_back (innerOffsets.size()-1);
675 benchmarkUnpack.stopTimer ();
683 tool.setColumn (
outputColumns.at(1).name, innerOffsets.size(), innerOffsets.data());
685 tool.setColumn (
outputColumns.at(2).name, outerOffsets.size(), outerOffsets.data());
693 const std::vector<ColumnarOffsetType>* offsetColumn =
nullptr;
694 std::vector<ColumnarOffsetType> offsets = {0};
696 const std::vector<ColumnarOffsetType>* targetOffsetColumn =
nullptr;
703 : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+
"(unpack)"), benchmark (branchReader.columnName())
709 virtual bool connect (TTree *
tree, std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
712 if (
iter == requestedColumns.end())
719 throw std::runtime_error (
"offset name mismatch: " +
iter->second.offsetName +
" != " +
outputColumns.at(1).name);
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;
727 throw std::runtime_error (
"missing offset column: " +
iter->second.linkToName);
729 requestedColumns.erase (
iter);
731 if (
auto offsetIter = offsetColumns.find (
outputColumns.at(1).name); offsetIter != offsetColumns.end())
732 offsetColumn = offsetIter->second;
737 if (
iter != requestedColumns.end())
740 requestedColumns.erase (
iter);
750 offsets.push_back (0);
755 benchmark.startTimer ();
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)
763 if (element.isDefault())
767 columnData.push_back (element.index() + targetOffsetColumn->at (targetOffsetColumn->size()-2));
768 if (element.key() != targetKey)
772 targetKey = element.key();
773 std::cout <<
"assume target key for " << targetContainerName <<
" is " << std::hex << targetKey << std::dec << std::endl;
781 offsets.push_back (columnData.size());
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);
789 benchmarkUnpack.stopTimer ();
805 std::vector<ColumnarOffsetType> offsets = {0};
814 bool checkUnknownKeys =
false;
815 std::unordered_map<SG::sgkey_t,std::unordered_set<std::string>>
unknownKeys;
818 : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+
"(unpack)"), benchmark (branchReader.columnName())
830 for (
auto& [
key, forbiddenContainer] : unknownKeys)
832 std::cout <<
"unknown key: " << std::hex <<
key << std::dec <<
", allowed containers:";
835 if (forbiddenContainer.find (container) == forbiddenContainer.end())
836 std::cout <<
" " << container;
838 std::cout << std::endl;
842 virtual bool connect (TTree *
tree, std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
845 if (
iter == requestedColumns.end())
852 throw std::runtime_error (
"offset name mismatch: " +
iter->second.offsetName +
" != " +
outputColumns.at(1).name);
854 if (
containers.empty() ||
iter->second.variantLinkKeyColumn.empty())
855 throw std::runtime_error (
"no variant link containers for: " +
outputColumns.at(0).name);
857 throw std::runtime_error (
"variant link key column mismatch: " +
iter->second.variantLinkKeyColumn +
" != " +
outputColumns.at(2).name);
859 for ([[maybe_unused]]
auto& container :
containers)
861 keysColumn.push_back (keysColumn.size()+1);
862 containerOffsets.push_back (offsetColumns.at (container));
863 if (
auto iter = knownKeys.find (container);
iter != knownKeys.end())
865 containerKeys.push_back (
iter->second);
868 checkUnknownKeys =
true;
869 containerKeys.push_back (0
u);
873 requestedColumns.erase (
iter);
876 if (
iter != requestedColumns.end())
879 requestedColumns.erase (
iter);
883 if (
iter != requestedColumns.end())
886 requestedColumns.erase (
iter);
895 offsets.push_back (0);
900 benchmark.startTimer ();
902 benchmark.stopTimer ();
903 benchmarkUnpack.startTimer ();
904 for (
auto&
data : branchData)
906 for (
auto& element :
data)
908 if (element.isDefault())
916 if (element.key() == containerKeys[
i])
918 if (containerOffsets[
i]->back() <= element.index())
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();
927 if (
key == 0xff && checkUnknownKeys)
932 auto& forbiddenContainers = unknownKeys[element.key()];
935 if (containerOffsets[
i]->back() <= containerOffsets[
i]->at (containerOffsets[
i]->
size()-2) + element.index())
942 offsets.push_back (columnData.size());
944 benchmarkUnpack.stopTimer ();
961 std::vector<ColumnarOffsetType> offsets = {0};
968 : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+
"(unpack)"), benchmark (branchReader.columnName())
975 virtual bool connect (TTree *
tree, std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& , std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
978 if (
iter == requestedColumns.end())
985 throw std::runtime_error (
"offset name mismatch: " +
iter->second.offsetName +
" != " +
outputColumns.at(1).name);
987 requestedColumns.erase (
iter);
990 if (
iter == requestedColumns.end())
995 requestedColumns.erase (
iter);
998 if (
iter != requestedColumns.end())
1001 requestedColumns.erase (
iter);
1010 offsets.push_back (0);
1011 columnHashData.clear();
1016 benchmark.startTimer ();
1018 benchmark.stopTimer ();
1019 benchmarkUnpack.startTimer ();
1020 for (
auto&
data : branchData)
1022 columnData.insert (columnData.end(),
data.begin(),
data.end());
1023 offsets.push_back (columnData.size());
1024 columnHashData.push_back (std::hash<std::string> () (
data));
1026 benchmarkUnpack.stopTimer ();
1032 tool.setColumn (
outputColumns.at(0).name, columnData.size(), columnData.data());
1036 tool.setColumn (
outputColumns.at(2).name, columnHashData.size(), columnHashData.data());
1043 const std::vector<ColumnarOffsetType>* offsetColumns =
nullptr;
1044 std::vector<ColumnarOffsetType> offsets = {0};
1045 std::vector<ColumnarOffsetType> namesOffsets = {0};
1050 : termNames (std::move (val_termNames))
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"});
1058 virtual bool connect (TTree * , std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& offsetColumns, std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
1061 iter != requestedColumns.end())
1062 requestedColumns.erase (
iter);
1068 iter != requestedColumns.end())
1071 requestedColumns.erase (
iter);
1075 iter != requestedColumns.end())
1078 requestedColumns.erase (
iter);
1082 iter != requestedColumns.end())
1085 requestedColumns.erase (
iter);
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);
1098 offsets.push_back (0);
1100 namesOffsets.clear ();
1101 namesOffsets.push_back (0);
1107 for (
const auto& termName : termNames)
1109 namesData.insert (namesData.end(), termName.begin(), termName.end());
1110 namesOffsets.push_back (namesData.size());
1111 namesHash.push_back (std::hash<std::string> () (termName));
1113 offsets.push_back (namesHash.size());
1123 tool.setColumn (
outputColumns.at(2).name, namesOffsets.size(), namesOffsets.data());
1132 std::vector<ColumnarOffsetType> offsets = {0};
1138 : branchReader (val_branchName), benchmarkUnpack (branchReader.columnName()+
".samplingPattern(fallback)(unpack)"), benchmark (branchReader.columnName() +
".samplingPattern(fallback)")
1144 virtual bool connect (TTree *
tree, std::unordered_map<std::string,
const std::vector<ColumnarOffsetType>*>& , std::unordered_map<std::string,ColumnInfo>& requestedColumns)
override
1147 if (
iter == requestedColumns.end())
1154 throw std::runtime_error (
"offset name mismatch: " +
iter->second.offsetName +
" != " +
outputColumns.at(1).name);
1156 requestedColumns.erase (
iter);
1159 if (
iter == requestedColumns.end())
1164 requestedColumns.erase (
iter);
1172 offsets.push_back (0);
1177 benchmark.startTimer ();
1179 benchmark.stopTimer ();
1180 benchmarkUnpack.startTimer ();
1181 for (
auto data : branchData)
1183 columnData.push_back (
data->samplingPattern());
1185 offsets.push_back (columnData.size());
1186 benchmarkUnpack.stopTimer ();
1192 tool.setColumn (
outputColumns.at(0).name, columnData.size(), columnData.data());
1203 static std::once_flag
flag;
1204 std::call_once (
flag, [] ()
1206 #ifdef XAOD_STANDALONE
1215 throw std::runtime_error (
"missing ASG_TEST_FILE_LITE_MC");
1218 throw std::runtime_error (
"failed to open file");
1219 tree =
dynamic_cast<TTree*
> (
file->Get (
"CollectionTree"));
1221 throw std::runtime_error (
"failed to open tree");
1228 static std::atomic<unsigned>
index = 0;
1240 using namespace PhysliteTestHelpers;
1242 knownColumns.push_back (std::make_shared<ColumnDataEventCount> ());
1245 std::unordered_map<std::string,TBranch*>
branches;
1247 TIter branchIter (
tree->GetListOfBranches());
1248 TObject *
obj =
nullptr;
1249 while ((
obj = branchIter()))
1251 TBranch *
branch =
nullptr;
1252 if ((
branch =
dynamic_cast<TBranch*
>(
obj)))
1255 TIter subBranchIter (
branch->GetListOfBranches());
1256 while ((
obj = subBranchIter()))
1258 if (
auto subBranch =
dynamic_cast<TBranch*
>(
obj))
1259 branches.emplace (subBranch->GetName(), subBranch);
1267 if (
name.find (
"AuxDyn.") != std::string::npos ||
1268 name.find (
"Aux.") != std::string::npos)
1270 TClass *branchClass =
nullptr;
1271 EDataType branchType {};
1272 branch->GetExpectedType (branchClass, branchType);
1273 if (branchClass ==
nullptr)
1278 knownColumns.push_back (std::make_shared<ColumnDataScalar<std::int32_t>> (
branch->GetName()));
1281 knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint32_t>> (
branch->GetName()));
1284 knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint64_t>> (
branch->GetName()));
1287 knownColumns.push_back (std::make_shared<ColumnDataScalar<std::uint64_t>> (
branch->GetName()));
1290 knownColumns.push_back (std::make_shared<ColumnDataScalar<float>> (
branch->GetName()));
1298 if (*branchClass->GetTypeInfo() ==
typeid(std::vector<float>))
1300 knownColumns.push_back (std::make_shared<ColumnDataVector<float>> (
branch->GetName()));
1301 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<char>))
1303 knownColumns.push_back (std::make_shared<ColumnDataVector<char>> (
branch->GetName()));
1304 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<std::int8_t>))
1306 knownColumns.push_back (std::make_shared<ColumnDataVector<std::int8_t>> (
branch->GetName()));
1307 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<std::uint8_t>))
1309 knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint8_t>> (
branch->GetName()));
1310 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<std::int16_t>))
1312 knownColumns.push_back (std::make_shared<ColumnDataVector<std::int16_t>> (
branch->GetName()));
1313 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<std::uint16_t>))
1315 knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint16_t>> (
branch->GetName()));
1316 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<std::int32_t>))
1318 knownColumns.push_back (std::make_shared<ColumnDataVector<std::int32_t>> (
branch->GetName()));
1319 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<std::uint32_t>))
1321 knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint32_t>> (
branch->GetName()));
1322 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<std::int64_t>))
1324 knownColumns.push_back (std::make_shared<ColumnDataVector<std::int64_t>> (
branch->GetName()));
1325 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<std::uint64_t>))
1327 knownColumns.push_back (std::make_shared<ColumnDataVector<std::uint64_t>> (
branch->GetName()));
1328 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<std::vector<float>>))
1330 knownColumns.push_back (std::make_shared<ColumnDataVectorVector<float>> (
branch->GetName()));
1331 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<std::vector<std::int32_t>>))
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>>))
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>>>))
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>>>))
1342 knownColumns.push_back (std::make_shared<ColumnDataVectorVectorVector<unsigned char>> (
branch->GetName()));
1343 }
else if (*branchClass->GetTypeInfo() ==
typeid(std::vector<std::string>))
1345 knownColumns.push_back (std::make_shared<ColumnDataMetNames> (
branch->GetName()));
1357 knownColumns.push_back (std::make_shared<ColumnDataSamplingPattern> (
"egammaClusters"));
1359 knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::CaloClusterContainer>> (
"AnalysisElectronsAuxDyn.caloClusterLinks"));
1361 knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::TrackParticleContainer>> (
"GSFConversionVerticesAuxDyn.trackParticleLinks"));
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));
1367 knownColumns.push_back (std::make_shared<ColumnDataOutVector<float>> (
"AnalysisElectrons.sfOut", 0));
1368 knownColumns.push_back (std::make_shared<ColumnDataOutVector<char>> (
"AnalysisElectrons.validOut", 0));
1370 knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::CaloClusterContainer>> (
"AnalysisPhotonsAuxDyn.caloClusterLinks"));
1371 knownColumns.push_back (std::make_shared<ColumnDataVectorVectorLink<xAOD::VertexContainer>> (
"AnalysisPhotonsAuxDyn.vertexLinks"));
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));
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));
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));
1391 knownColumns.push_back (std::make_shared<ColumnDataOutVector<std::uint16_t>> (
"AnalysisJets.objectType",
xAOD::Type::Jet));
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));
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"));
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));
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"));
1412 knownColumns.push_back (std::make_shared<ColumnDataOutVector<MissingETBase::Types::bitmask_t>> (
"METAssoc_AnalysisMET.useObjectFlags", 0));
1417 std::unordered_map<std::string,ColumnInfo> requestedColumns;
1422 std::cout <<
"requested columns: " <<
name << std::endl;
1424 for (
auto&
column : knownColumns)
1426 if (
column->connect (
tree, offsetColumns, requestedColumns))
1427 usedColumns.push_back (
column);
1430 std::set<std::string> unclaimedColumns;
1431 for (
auto&
column : requestedColumns)
1433 if (!
column.second.isOptional)
1434 unclaimedColumns.insert (
column.first);
1436 std::cout <<
"optional column not claimed: " <<
column.first << std::endl;
1438 if (!unclaimedColumns.empty())
1440 std::string
message =
"columns not claimed:";
1441 for (
auto&
column : unclaimedColumns)
1443 throw std::runtime_error (
message);
1449 using namespace asg::msgUserCode;
1455 throw std::runtime_error (
"tool does not support systematics");
1456 std::cout <<
"applying systematic variation: " <<
sysName << std::endl;
1458 throw std::runtime_error (
"failed to apply systematic variation: " +
sysName);
1463 if (!containerRenames.empty())
1467 setupKnownColumns ();
1468 setupColumns (toolWrapper);
1470 Benchmark benchmark (
name);
1472 const std::vector<ColumnarOffsetType>* offsetColumn =
nullptr;
1473 if (!container.empty())
1475 auto iter = offsetColumns.find (container);
1476 if (
iter == offsetColumns.end())
1477 throw std::runtime_error (
"missing size column: " + container);
1478 offsetColumn =
iter->second;
1481 const auto numberOfEvents =
tree->GetEntries();
1484 for (; benchmark.getTotalTime() < targetTime; ++
entry)
1487 for (
auto&
column : usedColumns)
1491 if (
entry + 1 == numberOfEvents)
1492 std::cout <<
"average size: " <<
float (
totalSize + offsetColumn->back()) / numberOfEvents << std::endl;
1494 if ((
entry + 1) % batchSize == 0)
1498 for (
auto&
column : usedColumns)
1499 column->setData (columnData);
1500 benchmark.startTimer ();
1502 benchmark.stopTimer ();
1503 for (
auto&
column : usedColumns)
1507 std::cout <<
"Total entries read: " <<
entry << std::endl;
1511 #ifdef XAOD_STANDALONE
1519 #ifdef XAOD_STANDALONE
1520 Benchmark benchmarkEmptyClear (
name +
" empty clear");
1521 Benchmark benchmarkCallClear (
name +
" call clear");
1522 Benchmark benchmarkPrepClear (
name +
" prep clear");
1524 Benchmark benchmarkCall (
name +
" call");
1525 Benchmark benchmarkPrep (
name +
" prep");
1526 Benchmark benchmarkGetEntry (
name +
" getEntry");
1528 const auto numberOfEvents =
event.getEntries();
1529 if (numberOfEvents == 0){
1530 throw std::runtime_error (
"ColumnarPhysLiteTest: numberOfEvents == 0");
1541 for (; benchmarkCall.getTotalTime() < targetTime && benchmarkPrep.getTotalTime() + benchmarkGetEntry.getTotalTime() < 20 * targetTime; ++
entry)
1543 benchmarkGetEntry.startTimer ();
1544 event.getEntry (
entry % numberOfEvents);
1545 benchmarkGetEntry.stopTimer ();
1547 args.inputContainer = container;
1548 args.outputContainer = container +
"Copy1";
1549 args.isPrepCall =
true;
1550 benchmarkPrep.startTimer ();
1552 benchmarkPrep.stopTimer ();
1553 args.outputContainer = container +
"Copy2";
1554 args.isPrepCall =
false;
1555 #ifdef XAOD_STANDALONE
1556 benchmarkPrepClear.startTimer ();
1558 benchmarkPrepClear.stopTimer ();
1560 benchmarkCall.startTimer ();
1562 benchmarkCall.stopTimer ();
1563 #ifdef XAOD_STANDALONE
1564 benchmarkCallClear.startTimer ();
1566 benchmarkCallClear.stopTimer ();
1567 benchmarkEmptyClear.startTimer ();
1569 benchmarkEmptyClear.stopTimer ();
1572 std::cout <<
"Total entries read: " <<
entry << std::endl;