17#include <TChainElement.h>
20#include <TFriendElement.h>
22#include <TMethodCall.h>
36#ifndef XAOD_STANDALONE
74 :
Event(
"xAOD::TEvent", ctx),
95 "Did not call finishWritingTo() before destroying the TEvent object!");
111 if (pattern.size()) {
120 return StatusCode::SUCCESS;
134 std::string_view treeName) {
137 if (
file ==
nullptr) {
139 return StatusCode::SUCCESS;
165 ATH_MSG_ERROR(
"Couldn't find metadata tree on input. Object is unusable!");
166 return StatusCode::FAILURE;
173 return StatusCode::FAILURE;
178 ATH_MSG_WARNING(
"Was expecting a metadata tree with size 1, instead of "
180 ATH_MSG_WARNING(
"The input file was most probably produced by hadd...");
186 static const std::string eventFormatTypeName =
188 ::TClass* cl = ::TClass::GetClass(eventFormatTypeName.c_str());
195 auto readEventFormatMetadata =
196 [&](std::string_view thisTreeName) -> StatusCode {
198 TTree* metaTree =
file->Get<TTree>(thisTreeName.data());
199 if (metaTree ==
nullptr) {
200 ATH_MSG_ERROR(
"Couldn't find metadata tree \"" << thisTreeName
202 return StatusCode::FAILURE;
205 if (metaTree->LoadTree(0) < 0) {
207 << thisTreeName <<
"\"");
208 return StatusCode::FAILURE;
212 const std::string eventFormatBranchName =
214 if (!metaTree->GetBranch(eventFormatBranchName.c_str())) {
218 ATH_MSG_INFO(
"Input file provides no event or metadata");
219 return StatusCode::RECOVERABLE;
226 metaTree->SetBranchAddress(eventFormatBranchName.c_str(), &format, &br);
228 ATH_MSG_ERROR(
"Failed to connect to xAOD::EventFormat object");
229 return StatusCode::FAILURE;
234 for (
const auto &[key, element] : *format) {
245 return StatusCode::SUCCESS;
251 if (
sc.isRecoverable()) {
254 return StatusCode::SUCCESS;
261 std::set<std::string> lOtherMetaTreeNames = {};
262 TList* lKeys =
file->GetListOfKeys();
265 for (
int iKey = 0; iKey < lKeys->GetEntries(); iKey++) {
267 std::string keyName = lKeys->At(iKey)->GetName();
274 const char* className = ((::TKey* )lKeys->At(iKey))->GetClassName();
275 static constexpr Bool_t LOAD = kFALSE;
276 static constexpr Bool_t SILENT = kTRUE;
277 ::TClass* cl = ::TClass::GetClass(className, LOAD, SILENT);
278 if ((cl !=
nullptr) && cl->InheritsFrom(::TTree::Class())) {
280 lOtherMetaTreeNames.insert(std::move(keyName));
287 for (
const std::string &metaTreeName : lOtherMetaTreeNames) {
288 ATH_CHECK(readEventFormatMetadata(metaTreeName));
311 stats.setNEvents(stats.nEvents() +
m_inTree->GetEntries());
317 listener->handle(beginIncident);
326 listener->handle(endIncident);
330 return StatusCode::SUCCESS;
353 if (useTreeCache && (!
m_inChain->GetCacheSize())) {
363 ATH_MSG_ERROR(
"Couldn't get the list of files from the input TChain");
364 return StatusCode::FAILURE;
366 if (!
files->GetEntries()) {
367 ATH_MSG_ERROR(
"No files are present in the received TChain");
368 return StatusCode::FAILURE;
370 const ::TChainElement* chEl =
371 dynamic_cast<const ::TChainElement*
>(
files->At(0));
374 return StatusCode::FAILURE;
377 std::unique_ptr<TFile> dummyFile{TFile::Open(chEl->GetTitle())};
380 return StatusCode::FAILURE;
395 return StatusCode::SUCCESS;
405 ::TFile*
file =
tree->GetCurrentFile();
423 return StatusCode::SUCCESS;
435 std::string_view treeName) {
440 return StatusCode::FAILURE;
445 ATH_MSG_ERROR(
"Object already writing to a file. Close that file first!");
446 return StatusCode::FAILURE;
454 m_outTree = std::make_unique<TTree>(treeName.data(),
"xAOD event tree");
464 return StatusCode::SUCCESS;
487 ATH_MSG_ERROR(
"The object doesn't seem to be connected to an output file!");
488 return StatusCode::FAILURE;
498 listener->handle(incident);
512 return StatusCode::SUCCESS;
518 metatree->SetAutoSave(10000);
519 metatree->SetAutoFlush(-30000000);
520 metatree->SetDirectory(
file);
528 }
catch (
const CxxUtils::ClassName::ExcBadClassName &
e) {
529 ::Error(
"xAOD::TEvent::finishWritingTo",
530 XAOD_MESSAGE(
"Class name parsing fails for %s ! "),
e.what());
531 return StatusCode::FAILURE;
537 std::vector<std::pair<std::string, TObjectManager* >> outputMetaObjects;
541 if (objMgr ==
nullptr) {
543 return StatusCode::FAILURE;
545 outputMetaObjects.emplace_back(key, objMgr);
550 for (
auto &[key, mgr] : outputMetaObjects) {
554 const ::Int_t splitLevel = (key.ends_with(
"Aux.") ? 1 : 0);
556 *(mgr->branchPtr()) =
557 metatree->Branch(key.c_str(), mgr->holder()->getClass()->GetName(),
558 mgr->holder()->getPtr(), 32000, splitLevel);
559 if (!mgr->branch()) {
561 << mgr->holder()->getClass()->GetName() <<
"/" << key
563 return StatusCode::FAILURE;
567 static constexpr bool METADATA =
true;
572 if (metatree->Fill() <= 0) {
573 ATH_MSG_ERROR(
"Failed to write event format metadata into the output");
574 metatree->SetDirectory(
nullptr);
575 return StatusCode::FAILURE;
580 metatree->SetDirectory(
nullptr);
586 return StatusCode::SUCCESS;
625 static constexpr bool TOP_STORE =
true;
627 key, TOP_STORE, mode), key)
629 ATH_MSG_ERROR(
"Couldn't connect TAuxStore object to the output");
698 const ::Long64_t fileEntry =
m_inChain->LoadTree(entry);
701 <<
" from the input chain");
715 static constexpr bool USE_TREE_CACHE =
false;
740 <<
" from the input file");
756 static const std::string dynStorePostfix =
"Aux.Dynamic";
757 if (key.ends_with(dynStorePostfix)) {
765 static constexpr bool SILENT =
true;
766 static constexpr bool METADATA =
false;
773 result += mgr->getEntry(getall);
781 listener->handle(incident);
800 return m_inChain->GetListOfFiles()->GetEntries();
836 ::Long64_t entry = 0;
837 for (::Long64_t i = 0; i <
file; ++i) {
878 std::string unsetObjects;
879 std::vector<std::pair<std::string, TVirtualManager* >> outputObjectsCopy;
882 outputObjectsCopy.emplace_back(key, mgr.get());
884 for (
auto &[key, mgr] : outputObjectsCopy) {
886 if (!mgr->create()) {
889 if (unsetObjects.size()) {
890 unsetObjects +=
", ";
892 unsetObjects.append(
"\"" + key +
"\"");
898 static constexpr bool METADATA =
false;
901 "in the output for object \""
908 if (unsetObjects.size()) {
909 ATH_MSG_ERROR(
"The following objects were not set in the current event: "
917 ATH_MSG_ERROR(
"Output tree filling failed with return value: " << ret);
937 std::vector<std::string> &vkeys,
938 bool metadata)
const {
940 std::set<std::string>
keys;
944 std::vector<TObjArray* > fullListOfBranches = {};
950 fullListOfBranches.push_back(
m_inMetaTree->GetListOfBranches());
956 fullListOfBranches.push_back(
m_inTree->GetListOfBranches());
961 TList* fList =
m_inTree->GetListOfFriends();
963 for (TObject* feObj : *fList) {
966 auto* pElement =
dynamic_cast<TFriendElement*
>(feObj);
967 if (pElement ==
nullptr) {
970 TTree* friendTree = pElement->GetTree();
972 fullListOfBranches.push_back(friendTree->GetListOfBranches());
980 for (
const TObjArray* in : fullListOfBranches) {
982 for (
const TObject* obj : *in) {
984 if (obj ==
nullptr) {
987 const TBranch* element =
dynamic_cast<const TBranch*
>(obj);
990 return StatusCode::FAILURE;
992 const std::string objClassName = element->GetClassName();
993 std::string key = obj->GetName();
996 if (objClassName == targetClassName) {
997 ATH_MSG_DEBUG(
"Matched \"" << targetClassName <<
"\" to key \"" << key
999 keys.insert(std::move(key));
1006 ATH_MSG_DEBUG(
"Scanning input objects for \"" << targetClassName <<
"\"");
1007 for (
const auto &[key, vmgr] : inAux) {
1011 if (mgr ==
nullptr) {
1014 const std::string &objClassName = mgr->holder()->getClass()->GetName();
1017 if (objClassName == targetClassName) {
1018 ATH_MSG_DEBUG(
"Matched \"" << targetClassName <<
"\" to key \"" << key
1026 const TObjArray* out =
m_outTree->GetListOfBranches();
1029 for (
const TObject* obj : *out) {
1030 if (obj ==
nullptr) {
1033 const TBranch* element =
dynamic_cast<const TBranch*
>(obj);
1034 if (element ==
nullptr) {
1036 return StatusCode::FAILURE;
1038 const std::string objClassName = element->GetClassName();
1039 std::string key = obj->GetName();
1042 if (objClassName == targetClassName) {
1043 ATH_MSG_DEBUG(
"Matched \"" << targetClassName <<
"\" to key \"" << key
1045 keys.insert(std::move(key));
1053 ATH_MSG_DEBUG(
"Scanning output objects for \"" << targetClassName <<
"\"");
1054 for (
const auto &[key, vmgr] : outAux) {
1057 if (mgr ==
nullptr) {
1060 const std::string &objClassName = mgr->holder()->getClass()->GetName();
1063 if (objClassName == targetClassName) {
1064 ATH_MSG_DEBUG(
"Matched \"" << targetClassName <<
"\" to key \"" << key
1070 vkeys.insert(vkeys.end(),
keys.begin(),
keys.end());
1073 return StatusCode::SUCCESS;
1098 return StatusCode::FAILURE;
1106 return StatusCode::SUCCESS;
1110 if (silent ==
false) {
1113 return StatusCode::RECOVERABLE;
1119 if (silent ==
false) {
1127 ::TBranch* br =
m_inTree->GetBranch(key.c_str());
1128 if (br ==
nullptr) {
1133 return StatusCode::RECOVERABLE;
1137 br->SetMakeClass(0);
1141 std::string className = br->GetClassName();
1142 if (className ==
"") {
1146 className = ef->className();
1149 "Couldn't find an appropriate type with a dictionary for branch \""
1151 return StatusCode::FAILURE;
1154 ::TClass* realClass = ::TClass::GetClass(className.c_str());
1155 if (((!realClass) || (!realClass->IsLoaded())) && ef) {
1159 className = ef->className();
1160 realClass = ::TClass::GetClass(className.c_str());
1162 if ((!realClass) || (!realClass->IsLoaded())) {
1165 "Couldn't find an appropriate type with a dictionary for branch \""
1167 return StatusCode::FAILURE;
1171#ifndef XAOD_STANDALONE
1177 static const ::EDataType dataType = kOther_t;
1183 void* ptr =
nullptr;
1188 if (mgr ==
nullptr) {
1189 ATH_MSG_ERROR(
"Couldn't access output manager for: " << key);
1190 return StatusCode::FAILURE;
1193 ptr = mgr->holder()->get();
1199 if (ptr ==
nullptr) {
1200 ptr = realClass->New();
1205 auto mgr = std::make_unique<TObjectManager>(
1206 nullptr, std::make_unique<THolder>(ptr, realClass), renewOnRead);
1215 << key <<
"\" is " << br->GetSplitLevel()
1216 <<
". This can only be read in kAthenaAccess mode.");
1218 *(mgr->holder()->getPtr()) =
nullptr;
1220 return StatusCode::FAILURE;
1224 const ::Int_t status =
1225 m_inTree->SetBranchAddress(key.c_str(), mgr->holder()->getPtr(),
1226 mgr->branchPtr(), realClass, dataType, kTRUE);
1229 << className <<
"\" to input branch \"" << key
1230 <<
"\". Return code: " << status);
1232 *(mgr->holder()->getPtr()) = 0;
1234 return StatusCode::FAILURE;
1254 return StatusCode::SUCCESS;
1270 return StatusCode::FAILURE;
1275 return StatusCode::SUCCESS;
1280 if (br ==
nullptr) {
1281 if (silent ==
false) {
1283 <<
"\" not available on input");
1285 return StatusCode::RECOVERABLE;
1289 if (br->GetEntries() == 0) {
1290 if (silent ==
false) {
1292 <<
"\" doesn't hold any data");
1294 return StatusCode::RECOVERABLE;
1298 br->SetMakeClass(0);
1302 ::EDataType dt = kOther_t;
1303 if (br->GetExpectedType(cl, dt) || (!cl)) {
1304 ATH_MSG_ERROR(
"Couldn't get the type for metadata branch \"" << key
1306 return StatusCode::FAILURE;
1310 void* ptr = cl->New();
1312 auto mgr = std::make_unique<TObjectManager>(
1313 nullptr, std::make_unique<THolder>(ptr, cl), renewOnRead);
1317 key.c_str(), mgr->holder()->getPtr(), mgr->branchPtr(), cl, dt, kTRUE);
1320 << cl->GetName() <<
"\" to input branch \"" << key
1321 <<
"\". Return code: " << status);
1323 *(mgr->holder()->getPtr()) = 0;
1325 return StatusCode::FAILURE;
1334 ATH_MSG_ERROR(
"Couldn't read in metadata object with key \"" << key
1336 return StatusCode::FAILURE;
1349 static constexpr bool METADATA =
true;
1354 return StatusCode::SUCCESS;
1371 return StatusCode::FAILURE;
1375 if ((!
m_inTree->GetBranch(prefix.c_str())) &&
1379 return StatusCode::SUCCESS;
1384 return StatusCode::SUCCESS;
1392 static constexpr bool SILENT =
false;
1396 return StatusCode::SUCCESS;
1402 static constexpr bool TOP_STORE =
true;
1403 auto store = std::make_unique<TAuxStore>(
1417 static constexpr bool IS_OWNER =
true;
1419 std::make_unique<TAuxManager>(store.release(), IS_OWNER);
1422 return StatusCode::SUCCESS;
1427 return StatusCode::FAILURE;
1443 return StatusCode::SUCCESS;
1449 return StatusCode::FAILURE;
1457 static constexpr bool SILENT =
false;
1461 return StatusCode::SUCCESS;
1467 static constexpr bool TOP_STORE =
true;
1468 auto store = std::make_unique<TAuxStore>(
1482 static constexpr bool IS_OWNER =
true;
1484 std::make_unique<TAuxManager>(store.release(), IS_OWNER);
1487 return StatusCode::SUCCESS;
1492 return StatusCode::FAILURE;
1512 (isAuxStore ==
false)) {
1513 return StatusCode::SUCCESS;
1526 auto itr = objects.find(key +
"Aux.");
1527 if (itr == objects.end()) {
1530 return StatusCode::SUCCESS;
1532 auxMgr = itr->second.get();
1533 auxKey = key +
"Aux.";
1536 if (metadata ==
false) {
1538 const ::Int_t readBytes = auxMgr->
getEntry();
1539 if (readBytes < 0) {
1541 "Couldn't load current entry for auxiliary object with key \""
1543 return StatusCode::FAILURE;
1548 const std::string dynAuxKey = auxKey +
"Dynamic";
1549 auto dynAuxMgr = objects.find(dynAuxKey);
1551 if ((dynAuxMgr != objects.end()) &&
1557 dynAuxMgr->second->getEntry();
1568 auto dynAuxMgr = objects.find(dynAuxKey);
1569 if (dynAuxMgr == objects.end()) {
1571 return StatusCode::FAILURE;
1573 dynAuxMgr->second->getEntry();
1580 return StatusCode::SUCCESS;
1586 switch (mgr.holder()->typeKind()) {
1601 if (
vec && (!
vec->trackIndices())) {
1602 Details::forceTrackIndices(*
vec);
1606 if ((!
vec) && (!aux)) {
1608 << mgr.holder()->getClass()->GetName()
1609 <<
"\" as SG::AuxVectorBase or SG::AuxElement");
1610 return StatusCode::FAILURE;
1614 const SG::IConstAuxStore* store = 0;
1615#ifndef XAOD_STANDALONE
1623 << auxKey <<
"\" is not of the right type");
1624 return StatusCode::FAILURE;
1635#ifndef XAOD_STANDALONE
1643 << auxKey <<
"\" is not of the right type");
1644 return StatusCode::FAILURE;
1646 void* p = omgr->
holder()->
getAs(
typeid(SG::IConstAuxStore));
1647 SG::IConstAuxStore* store1 =
reinterpret_cast<SG::IConstAuxStore*
>(p);
1649#ifndef XAOD_STANDALONE
1655 return StatusCode::FAILURE;
1658#ifndef XAOD_STANDALONE
1660 if (store_nc)[[
likely]] {
1664 return StatusCode::FAILURE;
1670 vec->setStore(store);
1672 aux->setStore(store);
1675 return StatusCode::FAILURE;
1679 return StatusCode::SUCCESS;
1698 const std::string &key,
bool overwrite,
bool metadata,
1704 "No output tree defined. Did you forget to call writeTo(...)?");
1705 return StatusCode::FAILURE;
1715 ATH_MSG_ERROR(
"Meta-object \"" << typeName <<
"\"/\"" << key
1716 <<
"\" already recorded");
1717 return StatusCode::FAILURE;
1720 TClass* cl = TClass::GetClass(typeName.c_str());
1722 ATH_MSG_ERROR(
"Didn't find dictionary for type: " << typeName);
1723 return StatusCode::FAILURE;
1728 nullptr, std::make_unique<THolder>(obj, cl, isOwner), renewOnRead);
1730 return StatusCode::SUCCESS;
1737 <<
"\" already accessed from the input, can't be "
1738 "overwritten in memory");
1739 return StatusCode::FAILURE;
1743 const Int_t splitLevel = (key.ends_with(
"Aux.") ? 1 : 0);
1750 TClass* cl = TClass::GetClass(typeName.c_str());
1751 if (cl ==
nullptr) {
1752 ATH_MSG_ERROR(
"Didn't find dictionary for type: " << typeName);
1753 return StatusCode::FAILURE;
1764 auto mgr = std::make_unique<TObjectManager>(
1765 nullptr, std::make_unique<THolder>(obj, cl, isOwner), renewOnRead);
1770 static constexpr Int_t basketSize = 32000;
1772 m_outTree->Branch(key.c_str(), cl->GetName(),
1775 ATH_MSG_ERROR(
"Failed to create branch \"" << key <<
"\" out of type \""
1776 << cl->GetName() <<
"\"");
1779 return StatusCode::FAILURE;
1784 static constexpr bool METADATA =
false;
1789 return StatusCode::SUCCESS;
1795 ATH_MSG_ERROR(
"Manager object of the wrong type encountered");
1796 return StatusCode::FAILURE;
1805 TClass* cl = TClass::GetClass(typeName.c_str());
1807 ::strcmp(cl->GetName(), omgr->
holder()->
getClass()->GetName())) {
1809 << key <<
"\" the previous type was \""
1811 <<
"\", but the newly requested type is \"" << typeName
1813 return StatusCode::FAILURE;
1821 static constexpr bool METADATA =
false;
1825 return StatusCode::SUCCESS;
1833 if (iomgr !=
nullptr) {
1835 static const bool OVERWRITE =
true;
1836 static const bool IS_OWNER =
true;
1838 key, OVERWRITE, metadata, IS_OWNER));
1839 return StatusCode::SUCCESS;
1844 if (auxmgr !=
nullptr) {
1848 "TAuxStore auxiliary objects can only be recorded for event data");
1849 return StatusCode::FAILURE;
1853 return StatusCode::SUCCESS;
1857 ATH_MSG_ERROR(
"Unknown auxiliary store manager type encountered");
1858 return StatusCode::FAILURE;
1871 return StatusCode::SUCCESS;
1876 ATH_MSG_ERROR(
"Function called on an uninitialised object");
1877 return StatusCode::FAILURE;
1886 for (; itr != end; ++itr) {
1889 const std::string &branchName = itr->second.branchName();
1892 if (branchName.find(
"Aux.") != std::string::npos) {
1901 const std::string intName = branchName.substr(0, branchName.size() - 4);
1909 ::Bool_t auxFound = kFALSE;
1912 std::vector<TObjArray* > fullListOfBranches = {};
1914 fullListOfBranches.push_back(
m_inTree->GetListOfBranches());
1917 if (
m_inTree->GetListOfFriends()) {
1919 TList* fList =
m_inTree->GetListOfFriends();
1921 for (TObject* feObj : *fList) {
1924 auto* pElement =
dynamic_cast<TFriendElement*
>(feObj);
1927 TTree* friendTree = pElement->GetTree();
1929 fullListOfBranches.push_back(friendTree->GetListOfBranches());
1934 for (TObjArray* branches : fullListOfBranches) {
1935 for (Int_t i = 0; i < branches->GetEntriesFast(); ++i) {
1936 if (!branches->At(i))
1939 const TString
name(branches->At(i)->GetName());
1940 if (
name.BeginsWith(branchName) ||
name.BeginsWith(dynName)) {
1948 << intName <<
"\" belonging to branch \""
1949 << branchName <<
"\"");
1956 ::TClass* cl = ::TClass::GetClass(el->className().c_str());
1957 if ((!cl) || (!cl->IsLoaded())) {
1959 << el->className() <<
"\"");
1966 static ::TClass*
const baseCl = ::TClass::GetClass(baseName.c_str());
1968 ATH_MSG_ERROR(
"Couldn't get dictionary for type \"" << baseName
1970 return StatusCode::FAILURE;
1980 static constexpr bool TOP_STORE =
true;
1982 static constexpr bool PRINT_WARNINGS =
false;
1990 stats.branch(branchName,
id);
1994 stats.setBranchNum(stats.branchNum() + temp.
getAuxIDs().size());
1999 const ::TBranch* container =
m_inTree->GetBranch(branchName.c_str());
2008 return StatusCode::SUCCESS;
2024 const std::string &key) {
2029 "No output tree defined. Did you forget to call writeTo(...)?");
2030 return StatusCode::FAILURE;
2034 const std::set<std::string>* filter = 0;
2037 filter = &(filter_itr->second);
2046 store->selectAux(*filter);
2051 static constexpr bool OWNS_STORE =
true;
2053 std::make_unique<TAuxManager>(store.release(), OWNS_STORE);
2056 return StatusCode::SUCCESS;
2060 if (vitr->second->object() == store.get()) {
2062 return StatusCode::SUCCESS;
2071 if (mgr ==
nullptr) {
2073 << key <<
"\" already exists, and is not of type TAuxStore");
2074 return StatusCode::FAILURE;
2079 store->selectAux(*filter);
2086 mgr->setObject(store.release());
2089 return StatusCode::SUCCESS;
2103 ::TMethodCall setNameCall;
2107 setNameCall.InitWithPrototype(mgr.holder()->getClass(),
"setName",
2109 if (setNameCall.IsValid()) {
2112 const ::TString params =
2113 ::TString::Format(
"\"%s\"", mgr.branch()->GetName());
2114 const char* charParams = params.Data();
2115 setNameCall.Execute(mgr.holder()->get(), charParams);
2118 ATH_MSG_WARNING(
"Couldn't find setName(...) function for container \""
2119 << mgr.branch()->GetName() <<
"\" (type: "
2120 << mgr.holder()->getClass()->GetName() <<
")");
2125 static const TClass*
const holderClass =
2127 if (!mgr.holder()->getClass()->InheritsFrom(holderClass)) {
2129 return StatusCode::SUCCESS;
2137 return StatusCode::FAILURE;
2144 static constexpr bool TOP_STORE =
false;
2146 auto store = std::make_unique<TAuxStore>(
2147 ctx, mgr.branch()->GetName(), TOP_STORE,
2163 static constexpr bool SHARED_OWNER =
false;
2164 m_inputObjects[std::string(mgr.branch()->GetName()) +
"Dynamic"] =
2165 std::make_unique<TAuxManager>(store.get(), SHARED_OWNER);
2168 storeHolder->
setStore(store.release());
2171 return StatusCode::SUCCESS;
2194 return StatusCode::SUCCESS;
2198 if (!mgr->holder()->getClass()->InheritsFrom(
"SG::IAuxStoreIO")) {
2199 return StatusCode::SUCCESS;
2207 return StatusCode::FAILURE;
2214 auto item_itr =
m_auxItemList.find(mgr->branch()->GetName());
2216 sel.selectAux(item_itr->second);
2227 if (auxids.empty()) {
2228 return StatusCode::SUCCESS;
2232 const std::string dynNamePrefix =
2241 typedef std::pair<std::string, SG::auxid_t> AuxVarSort_t;
2242 std::vector<AuxVarSort_t> varsort;
2243 varsort.reserve(auxids.size());
2245 varsort.emplace_back(
r.getName(
id),
id);
2247 std::sort(varsort.begin(), varsort.end());
2250 for (
const auto &p : varsort) {
2256 const std::string brName = dynNamePrefix + p.first;
2259 Object_t::iterator bmgr = objects.find(brName);
2262 if (bmgr == objects.end()) {
2265 const std::type_info* brType = aux->
getIOType(
id);
2268 return StatusCode::FAILURE;
2271 std::string brProperTypeName =
"<unknown>";
2277 if (strlen(brType->name()) == 1) {
2280 brProperTypeName = brTypeName;
2284 if (rootType ==
'\0') {
2286 << brName <<
"\" of type \"" << brTypeName <<
"\"");
2287 return StatusCode::FAILURE;
2291 std::ostringstream leaflist;
2292 leaflist << brName <<
"/" << rootType;
2295 static constexpr bool IS_OWNER =
false;
2296 auto auxmgr = std::make_unique<TPrimitiveAuxBranchManager>(
2300 static constexpr Int_t BASKET_SIZE = 32000;
2301 *(auxmgr->branchPtr()) =
2302 outTree.Branch(brName.c_str(), auxmgr->holder()->get(),
2303 leaflist.str().c_str(), BASKET_SIZE);
2304 if (!auxmgr->branch()) {
2306 << brName <<
"\" out of type \"" << brProperTypeName
2309 *(auxmgr->holder()->getPtr()) = 0;
2310 return StatusCode::FAILURE;
2312 br = auxmgr->branch();
2315 objects[brName] = std::move(auxmgr);
2320 static constexpr Bool_t LOAD_IF_NOT_FOUND = kTRUE;
2321 static constexpr Bool_t SILENT = kTRUE;
2322 TClass* cl = TClass::GetClass(*brType, LOAD_IF_NOT_FOUND, SILENT);
2323 if (cl ==
nullptr) {
2326 cl = TClass::GetClass(brTypeName.c_str());
2328 if (cl ==
nullptr) {
2330 << brName <<
"\" of type \"" << brTypeName <<
"\"");
2331 return StatusCode::FAILURE;
2336 brProperTypeName = cl->GetName();
2339 static constexpr bool IS_OWNER =
false;
2340 auto auxmgr = std::make_unique<TAuxBranchManager>(
2344 static constexpr Int_t BASKET_SIZE = 32000;
2345 static constexpr Int_t SPLIT_LEVEL = 0;
2346 *(auxmgr->branchPtr()) = outTree.Branch(brName.c_str(), cl->GetName(),
2347 auxmgr->holder()->getPtr(),
2348 BASKET_SIZE, SPLIT_LEVEL);
2349 if (!auxmgr->branch()) {
2351 << brName <<
"\" out of type \"" << brProperTypeName
2354 *(auxmgr->holder()->getPtr()) = 0;
2355 return StatusCode::FAILURE;
2357 br = auxmgr->branch();
2360 objects[brName] = std::move(auxmgr);
2365 if (outTree.GetEntries()) {
2366 void* ptr = br->GetAddress();
2368 for (::Long64_t i = 0; i < outTree.GetEntries(); ++i) {
2371 br->SetAddress(ptr);
2378 mgr->branch()->GetName(),
2387 bmgr = objects.find(brName);
2388 if (bmgr == objects.end()) {
2389 ATH_MSG_FATAL(
"There is an internal logic error in the code...");
2390 return StatusCode::FAILURE;
2396 const_cast<void*
>(
static_cast<const void*
>(aux->
getIOData(
id)));
2397 bmgr->second->setObject(nc_data);
2401 return StatusCode::SUCCESS;
2409 return StatusCode::FAILURE;
2413 const std::set<std::string>* filter = 0;
2416 filter = &(filter_itr->second);
2425 store->selectAux(*filter);
2430 static constexpr bool OWNS_STORE =
false;
2431 m_outputObjects[key] = std::make_unique<TAuxManager>(store, OWNS_STORE);
2434 return StatusCode::SUCCESS;
2438 if (vitr->second->object() == store) {
2440 return StatusCode::SUCCESS;
2449 if (mgr ==
nullptr) {
2451 << key <<
"\" already exists, and is not of type TAuxStore");
2452 return StatusCode::FAILURE;
2457 store->selectAux(*filter);
2464 mgr->setObject(store);
2467 return StatusCode::SUCCESS;
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_ERROR(x,...)
#define ATH_MSG_WARNING(x,...)
#define ATH_MSG_VERBOSE(x,...)
#define ATH_MSG_INFO(x,...)
#define ATH_MSG_FATAL(x,...)
Base class for elements of a container that can have aux data.
Handle mappings between names and auxid_t.
Manage index tracking and synchronization of auxiliary data.
std::vector< size_t > vec
Recursively separate out template arguments in a C++ class name.
Interface providing I/O for a generic auxiliary store.
virtual void lock()=0
Interface to allow an object to lock itself when made const in SG.
Temporarily change the current EventContext.
Define macros for attributes used to control the static checker.
Handle mappings between names and auxid_t.
static AuxTypeRegistry & instance()
Return the singleton registry instance.
Manage index tracking and synchronization of auxiliary data.
Interface for objects taking part in direct ROOT I/O.
AuxStoreType
Type of the auxiliary store.
@ AST_ContainerStore
The store describes a container.
@ AST_ObjectStore
The store describes a single object.
virtual AuxStoreType getStoreType() const =0
Return the type of the store object.
virtual void setStore(IAuxStore *store)=0
Give an auxiliary store object to the holder object.
Interface providing I/O for a generic auxiliary store.
virtual SG::auxid_set_t getSelectedAuxIDs() const
Get a list of dynamic variables that need to be written out.
virtual const std::type_info * getIOType(SG::auxid_t auxid) const =0
Return the type of the data to be stored for one aux data item.
virtual const void * getIOData(SG::auxid_t auxid) const =0
Return a pointer to the data to be stored for one aux data item.
Interface for non-const operations on an auxiliary store.
virtual void toTransient(const EventContext &ctx)=0
Perform post-read processing on this store.
Temporarily change the current EventContext.
A set of aux data identifiers.
Class helping in dealing with dynamic branch selection.
Manager for EDM objects created by ROOT.
const THolder * holder() const
Accessor to the Holder object.
EventFormat m_inputEventFormat
Format of the current input file.
const std::string & name() const override
Get the name of the instance.
std::set< std::string > m_inputMissingObjects
Objects that have been asked for, but were found to be missing in the current input.
const void * getInputObject(SG::sgkey_t key, const std::type_info &ti, bool silent) override
Function for retrieving an input object in a non-template way.
upgrade_mutex_t m_branchesMutex
Mutex for multithread synchronization.
std::unordered_map< std::string, std::unique_ptr< TVirtualManager > > Object_t
Definition of the internal data structure type.
Object_t m_inputObjects
Collection of all the managed input objects.
Event(std::string_view name, const EventContext *ctx=nullptr)
Constructor with a name.
static const char *const METADATA_OBJECT_NAME
Name of the metadata tree or RNTuple.
StatusCode keys(std::vector< std::string > &vkeys, bool metadata) const
Provide a list of all data object keys associated with a specific type.
void setActive() const
Set this event object as the currently active one.
SG::sgkey_t getHash(const std::string &key) const override
Function returning the hash describing an object name.
Object_t m_inputMetaObjects
Collection of all the managed input meta-objects.
std::unordered_map< std::string, std::set< std::string > > m_auxItemList
Rules for selecting which auxiliary branches to write.
EventFormat * m_outputEventFormat
Format of the current output file.
Object_t m_outputObjects
Collection of all the managed output object.
SG::SGKeyMap< BranchInfo > m_branches ATLAS_THREAD_SAFE
Map from hashed sgkey to BranchInfo.
AthContainers_detail::upgrading_lock< upgrade_mutex_t > upgrading_lock_t
Lock type for multithread synchronization.
const EventContext & currentContext() const
Return the event context corresponding to this event.
std::vector< TVirtualIncidentListener * > m_listeners
Listeners who should be notified when certain incidents happen.
Object_t m_outputMetaObjects
Collection of all the managed output meta-objects.
ReadStats & stats()
Access the object belonging to the current thread.
static IOStats & instance()
Singleton object accessor.
Class describing the access statistics of a collection of branches.
void nextEvent()
Function incrementing the processed event counter.
BranchStats * container(const std::string &name)
Access the description of a container. Creating it if necessary.
void setBranchNum(::Int_t num)
Set the total number of branches on the input.
void readContainer(const std::string &name)
Function incrementing the read counter on a specific container.
Manager for TAuxStore objects.
TAuxStore * getStore()
Get a type-specific pointer to the managed object.
const SG::IConstAuxStore * getConstStore() const
Get a convenience pointer to the managed object.
"ROOT @c TTree implementation" of IAuxStore
StatusCode readFrom(::TTree &tree, bool printWarnings=true)
Connect the object to an input TTree.
Helper class for making sure the current directory is preserved.
EAuxMode
Auxiliary store "mode".
@ kAthenaAccess
Access containers/objects like Athena does.
@ kClassAccess
Access auxiliary data using the aux containers.
@ kBranchAccess
Access auxiliary data branch-by-branch.
::TTree * m_inMetaTree
Pointer to the metadata tree in the input file.
StatusCode connectObject(const std::string &key, bool silent) override
Function setting up access to a particular object.
StatusCode connectMetaAux(const std::string &prefix, bool standalone) override
Function setting up access to a set of auxiliary branches for a metadata object.
StatusCode connectAux(const std::string &prefix, bool standalone) override
Function setting up access to a set of auxiliary branches.
StatusCode record(std::unique_ptr< TAuxStore > store, const std::string &key)
Internal function for adding an auxiliary store object to the output.
bool hasOutput() const override
Check if an output file is connected to the object.
std::unique_ptr< TChainStateTracker > m_inChainTracker
Optional object for tracking the state changes of an input TChain.
::Int_t getEntry(::Long64_t entry, ::Int_t getall=0) override
Function loading a given entry of the input TTree.
TEvent(EAuxMode mode=kClassAccess, const EventContext *ctx=nullptr)
Default constructor.
StatusCode setAuxStore(const std::string &key, Details::IObjectManager &mgr, bool metadata) override
Function connecting a DV object to its auxiliary store.
EAuxMode auxMode() const
Get what auxiliary access mode the object was constructed with.
bool hasInput() const override
Check if an input file is connected to the object.
StatusCode initStats()
Function to initialise the statistics for all Tree content.
::Long64_t m_entry
The entry to look at from the input tree.
::Long64_t getFiles() const
Get how many files are available on the currently defined input.
void setOtherMetaDataTreeNamePattern(const std::string &pattern)
Change the pattern used for collecting information from other MetaData trees NB: Additional MetaData ...
StatusCode finishWritingTo(TFile &file) override
Finish writing to an output file.
StatusCode getNames(const std::string &targetClassName, std::vector< std::string > &vkeys, bool metadata) const override
Function determining the list keys associated with a type name.
StatusCode setUpDynamicStore(TObjectManager &mgr, ::TTree *tree)
Function adding dynamic variable reading capabilities to an auxiliary store object.
std::regex m_otherMetaDataTreeNamePattern
::TChain * m_inChain
The (optional) chain provided as input.
StatusCode putAux(::TTree &outTree, TVirtualManager &mgr, bool metadata)
Function saving the dynamically created auxiliary properties.
EAuxMode m_auxMode
The auxiliary access mode.
StatusCode recordImpl(void *obj, const std::string &typeName, const std::string &key, bool overwrite, bool metadata, bool isOwner) override
Record an object into a connected output file.
::Int_t fill() override
Function filling one event into the output tree.
StatusCode readFrom(::TFile &inFile) override
Set up the reading of an input file from TFile This method implements the interface from Event.
virtual ~TEvent()
Destructor.
SG::IAuxStore * recordAux(const std::string &key, SG::IAuxStoreHolder::AuxStoreType type=SG::IAuxStoreHolder::AST_ContainerStore)
Add an auxiliary store object to the output.
std::unique_ptr<::TTree > m_outTree
The tree that we are writing to.
bool m_inTreeMissing
Internal status flag showing that an input file is open, but it doesn't contain an event tree.
::Int_t m_inTreeNumber
The number of the currently open tree in the input chain.
::Int_t getFile(::Long64_t file, ::Int_t getall=0)
Load the first event for a given file from the input TChain.
StatusCode writeTo(TFile &file) override
Connect the object to an output file.
::TTree * m_inTree
The main tree that we are reading from.
StatusCode connectMetaObject(const std::string &key, bool silent) override
Function setting up access to a particular metadata object.
::Long64_t getEntries() const override
Get how many entries are available from the current input file(s).
void add(std::string_view fileName)
Add information about a new file that got accessed.
static TFileAccessTracer & instance()
Access the singleton instance of this class.
This class takes care of holding EDM objects in memory.
void setOwner(::Bool_t state=kTRUE)
Set whether the holder should own its object.
void ** getPtr()
Return a typeless pointer to the held object's pointer.
const ::TClass * getClass() const
virtual void * getAs(const std::type_info &tid, ::Bool_t silent=kFALSE) const
Return the object as a specific pointer.
@ DATAVECTOR
A DataVector container.
@ AUXELEMENT
A type inheriting from SG::AuxElement.
Class describing a certain "incident" that is communicated to user code.
Manager for EDM objects created by ROOT.
::TBranch ** branchPtr()
Pointer to the branch's pointer.
virtual void setObject(void *obj) override
Function replacing the object being handled.
virtual::Int_t getEntry(::Int_t getall=0) override
Function for updating the object in memory if needed.
::TBranch * branch()
Accessor to the branch.
Class providing an interface for classes listening to xAOD incidents.
Interface class for the "manager classes".
virtual const void * object() const =0
Function getting a const pointer to the object being handled.
virtual::Int_t getEntry(::Int_t getall=0)=0
Function for updating the object in memory if needed.
void setStructMode(EStructMode mode)
Set the structure mode of the object to a new value.
EStructMode
"Structural" modes of the object
@ kUndefinedStore
The structure mode is not defined.
@ kObjectStore
The object describes a single object.
@ kContainerStore
The object describes an entire container.
virtual const SG::auxid_set_t & getAuxIDs() const override
Get the types(names) of variables handled by this container.
EStructMode structMode() const
Get what structure mode the object was constructed with.
std::vector< std::string > files
file names and file pointers
std::string normalizedTypeinfoName(const std::type_info &info)
Convert a type_info to a normalized string representation (matching the names used in the root dictio...
AuxElement(SG::AuxVectorData *container, size_t index)
Base class for elements of a container that can have aux data.
size_t auxid_t
Identifier for a particular aux data item.
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
bool hasAuxStore(const TClass &cl)
Helper function deciding if a given type "has an auxiliary store".
bool isAuxStore(const TClass &cl)
Helper function deciding if a given type "is an auxiliary store".
bool isStandalone(const TClass &cl)
Helper function deciding if a given type "is a standalone object".
static const ::Int_t BeginEvent
A new event was just loaded.
static const ::Int_t EndInputFile
The processing of an input file has finished.
static const ::Int_t MetaDataStop
The metadata for the output file should be written out.
static const ::Int_t BeginInputFile
A new input file was just opened.
std::string dynBranchPrefix(const std::string &key)
This function is used to figure out what to name dynamic auxiliary branches coming from a container c...
char rootType(char typeidType)
This function is used internally in the code when creating primitive dynamic auxiliary branches.
std::string getFirstBranchMatch(TTree *tree, const std::string &pre)
This function is used to search for a branch in a TTree that contains a given substring.
std::string getTypeName(const std::type_info &ti)
This function is necessary in order to create type names that ROOT can understand.
ICaloAffectedTool is abstract interface for tools checking if 4 mom is in calo affected region.
EventFormat_v1 EventFormat
Definition of the current event format version.
static const ::Int_t CACHE_SIZE
Size of a possible TTreeCache.
Helper to disable undefined behavior sanitizer for a function.
Convert a type_info to a normalized string representation (matching the names used in the root dictio...