xAOD::TAuxStore::impl Struct Reference

Collaboration diagram for xAOD::TAuxStore::impl:

Public Member Functions
StatusCode	scanInputTree ()
	Scan the input TTree for auxiliary branches.
const std::type_info *	auxBranchType (::TBranch &br, std::string_view auxName, bool staticBranch, std::string *expectedClassName=nullptr)
	Find the type_info to use as the aux type for a given branch.
StatusCode	setupAuxBranch (::TBranch &br, std::string_view auxName, bool staticBranch)
	Register one input branch as an available auxiliary variable.

Public Attributes
Members &	m_data
	Variables coming from AuxStoreBase.
int	m_basketSize = 2048
	The basket size for the output branches.
int	m_splitLevel = 0
	The split level for the output branches.
::TTree *	m_inTree = nullptr
	The TTree being read from.
::TTree *	m_outTree = nullptr
	The TTree being written to.
bool	m_inputScanned = false
	"Scan status" of the input TTree
std::vector< std::unique_ptr< TBranchHandle > >	m_branches
	Branches reading the various auxiliary variables.
std::vector< bool >	m_branchesWritten
	"Write status" of the different variables
std::vector< bool >	m_missingBranches
	Mark branches we've found to be missing.
mutex_t	m_mutex
	Mutex object used for multithreaded synchronisation.

Detailed Description

Definition at line 423 of file TAuxStore.cxx.

Member Function Documentation

auxBranchType()

const std::type_info * xAOD::TAuxStore::impl::auxBranchType ( ::TBranch & br, std::string_view auxName, bool staticBranch, std::string * expectedClassName = nullptr )

inline

Find the type_info to use as the aux type for a given branch.

Definition at line 545 of file TAuxStore.cxx.

                                              {
 
    // Get the branch's type:
    ::TClass* expectedClass = nullptr;
    ::EDataType expectedType = kOther_t;
    if (br.GetExpectedType(expectedClass, expectedType) &&
        ((!staticBranch) || (!auxName.starts_with("m_")))) {
      ::Warning("xAOD::TAuxStore::impl::auxBranchType",
                "Couldn't get the type of branch \"%s\"", br.GetName());
    }
 
    // Check for schema evolution:
    // If a branch has automatic schema evolution from one class to another,
    // then what we get from GetExpectedType will be the on-disk class.
    // What we have in memory is given by GetCurrentClass.
    if (expectedClass) {
      if (TBranchElement* bre = dynamic_cast<TBranchElement*>(&br)) {
        TClass* newClass = bre->GetCurrentClass();
        if (newClass && newClass != expectedClass) {
          expectedClass = newClass;
        }
      }
      if (expectedClassName) {
        *expectedClassName = expectedClass->GetName();
      }
    }
 
    // If this is a primitive variable, and we're still not sure whether this
    // is a store for an object or a container, the answer is given...
    if ((!expectedClass) &&
        (m_data.m_structMode == EStructMode::kUndefinedStore)) {
      m_data.m_structMode = EStructMode::kObjectStore;
    }
 
    // Get the type_info of the branch.
    const std::type_info* ti = nullptr;
    if (m_data.m_structMode == EStructMode::kObjectStore) {
      if (expectedClass) {
        ti = expectedClass->GetTypeInfo();
      } else {
        ti = &(Utils::getTypeInfo(expectedType));
      }
    } else {
      if (!expectedClass) {
        if ((!staticBranch) || (!auxName.starts_with("m_"))) {
          ::Warning("xAOD::TAuxStore::impl::auxBranchType",
                    "Couldn't get the type of branch \"%s\"", br.GetName());
        }
      } else {
        ::TVirtualCollectionProxy* prox = expectedClass->GetCollectionProxy();
 
        if (!prox) {
          TClass* cl2 = details::lookupVectorType(*expectedClass);
          if (cl2) {
            prox = cl2->GetCollectionProxy();
          }
        }
 
        if (!prox) {
          if ((!staticBranch) || (!auxName.starts_with("m_"))) {
            ::Warning("xAOD::TAuxStore::impl::auxBranchType",
                      "Couldn't get the type of branch \"%s\"", br.GetName());
          }
        } else {
          if (prox->GetValueClass()) {
            ti = prox->GetValueClass()->GetTypeInfo();
          } else {
            ti = &(Utils::getTypeInfo(prox->GetType()));
          }
        }
      }
    }
 
    return ti;
  }

scanInputTree()

StatusCode xAOD::TAuxStore::impl::scanInputTree ( )

inline

Scan the input TTree for auxiliary branches.

When writing an output tree, while reading information from an input tree, it can often happen that we want to copy the contents of some variables that we don't actually need during the event processing of this particular job. Since the user doesn't ask for all the possible input variables, this function needs to look at the input TTree, and try to figure out which of the branches in the tree belong to this object.

The function creates a "proper" or "virtual" auxiliary ID for each of the branches found, so they can be referenced in the "usual way" in the other parts of the code later on.

Returns

StatusCode::SUCCESS if the function was successful, something else otherwise

Definition at line 442 of file TAuxStore.cxx.

                             {
 
    // Check if an input tree is even available:
    if (!m_inTree) {
      // It's not an error if it isn't.
      return StatusCode::SUCCESS;
    }
 
    // Check if the input was already scanned:
    if (m_inputScanned) {
      return StatusCode::SUCCESS;
    }
 
    // Get a list of all branches in the tree:
    TObjArray* branches = m_inTree->GetListOfBranches();
 
    // Check each of them:
    for (Int_t i = 0; i < branches->GetEntriesFast(); ++i) {
 
      // The name of this top-level branch:
      const TString brName = branches->At(i)->GetName();
 
      // Access the branch pointer:
      TBranch* br = dynamic_cast<TBranch*>(branches->At(i));
      if (!br) {
        ::Fatal("xAOD::TAuxStore::impl::scanInputTree",
                XAOD_MESSAGE("Logic error detected"));
      }
 
      // For top-level stores let's scan the static branches as well:
      if (m_data.m_topStore && (brName == m_data.m_prefix)) {
 
        // Make sure the object has been instantiated so that aux data
        // registrations will have been done.
        br->SetAddress(0);
 
        // Get a list of its sub-branches:
        TObjArray* sbranches = br->GetListOfBranches();
 
        // ...and then loop over them:
        for (Int_t j = 0; j < sbranches->GetEntriesFast(); ++j) {
 
          // The name of the sub-branch:
          const TString brName = sbranches->At(j)->GetName();
 
          // Try to make a variable name out of the branch name:
          const TString auxName =
              brName(brName.Index(".") + 1, brName.Length());
 
          // Skip this entry if it refers to a base class:
          if (auxName.BeginsWith("xAOD::") || auxName.BeginsWith("SG::") ||
              (auxName == "ILockable")) {
            continue;
          }
 
          // The sub-branch:
          ::TBranch* sbr = dynamic_cast< ::TBranch*>(sbranches->At(j));
          if (!sbr) {
            ::Fatal("xAOD::TAuxStore::impl::scanInputTree",
                    XAOD_MESSAGE("Logic error detected"));
          }
 
          // Leave the rest up to the function that is shared with the
          // dynamic branches:
          //cppcheck-suppress nullPointerRedundantCheck
          RETURN_CHECK("xAOD::TAuxStore::impl::scanInputTree",setupAuxBranch(*sbr, auxName, true));
        }
 
        // Don't check the rest of the loop's body:
        continue;
      }
 
      // Check if it has the right prefix to be a dynamic variable:
      if (!brName.BeginsWith(m_data.m_dynPrefix.data())) {
        continue;
      }
      // It's possible to create dynamic variables with an empty name
      // as well. Which is a bug. Such variables are just ignored
      // for now.
      if (brName == m_data.m_dynPrefix) {
        ::Warning("xAOD::TAuxStore::impl::scanInputTree",
                  "Dynamic branch with empty name found on container: %s",
                  m_data.m_prefix.data());
        continue;
      }
 
      // The auxiliary property name:
      const TString auxName = brName(brName.Index(".") + 1, brName.Length());
 
      // Leave the rest up to the function that is shared with the
      // dynamic branches:
      RETURN_CHECK("xAOD::TAuxStore::impl::scanInputTree",
                   setupAuxBranch(*br, auxName, false));
    }
 
    // Okay, the input was successfully scanned:
    m_inputScanned = true;
 
    // Return gracefully:
    return StatusCode::SUCCESS;
  }

setupAuxBranch()

StatusCode xAOD::TAuxStore::impl::setupAuxBranch ( ::TBranch & br, std::string_view auxName, bool staticBranch )

inline

Register one input branch as an available auxiliary variable.

This function takes care of assigning an auxiliary ID to a given branch. It tries its best to find an auxiliary vector factory for the branch's type, but if it fails, it still falls back to using SG::AuxTypePlaceholder as the type. In which case of course only dumb copying will be possible for the given branch. (And no vector operations on the branch's payload until the variable of the branch is accessed explicitly.)

Parameters

br	Pointer to the branch under investigation
auxName	The name of the auxiliary property, extracted from the branch's name
staticBranch	kTRUE if this is a "static branch", and kFALSE if it's a dynamic one

Returns

StatusCode::SUCCESS if the function was successful, something else otherwise

Definition at line 641 of file TAuxStore.cxx.

                                               {
 
    // Get the (on disk) type of the branch.
    std::string expectedClassName;
    const std::type_info* ti =
        auxBranchType(br, auxName, staticBranch, &expectedClassName);
    if (ti == nullptr) {
      // If we didn't find a type_info for the branch, give up now...
      return StatusCode::SUCCESS;
    }
 
    // Get the registry:
    SG::AuxTypeRegistry& registry = SG::AuxTypeRegistry::instance();
 
    // Check if the registry already knows this variable name. If yes, let's
    // use the type known by the registry. To be able to deal with simple
    // schema evolution in dynamic branches.
    if (const SG::auxid_t regAuxid = registry.findAuxID(std::string{auxName});
        regAuxid != SG::null_auxid) {
      m_data.m_auxIDs.insert(regAuxid);
      return StatusCode::SUCCESS;
    }
 
    SG::AuxVarFlags flags = SG::AuxVarFlags::SkipNameCheck;
    SG::auxid_t linked_auxid = SG::null_auxid;
 
    if (SG::AuxTypeRegistry::isLinkedName(std::string{auxName})) {
      flags |= SG::AuxVarFlags::Linked;
    } else if (SG::AuxTypeRegistry::classNameHasLink(expectedClassName)) {
      std::string linkedAttr =
          SG::AuxTypeRegistry::linkedName(std::string{auxName});
      std::string linkedBranch = SG::AuxTypeRegistry::linkedName(br.GetName());
      ::TBranch* lbr = m_inTree->GetBranch(linkedBranch.c_str());
      const std::type_info* lti = nullptr;
      if (lbr) {
        lti = auxBranchType(*lbr, linkedAttr, staticBranch);
      }
      if (lti) {
        linked_auxid = registry.getAuxID(
            *lti, linkedAttr, "",
            SG::AuxVarFlags::SkipNameCheck | SG::AuxVarFlags::Linked);
      }
      if (linked_auxid == SG::null_auxid) {
        ::Error("xAOD::TAuxStore::impl::setupAuxBranch",
                "Could not find linked variable for %s type %s", auxName.data(),
                expectedClassName.c_str());
      }
    }
 
    // Check for an auxiliary ID for this branch:
    SG::auxid_t auxid =
        registry.getAuxID(*ti, std::string{auxName}, "", flags, linked_auxid);
 
    // First try to find a compiled factory for the vector type:
    if (auxid == SG::null_auxid) {
 
      // Construct the name of the factory's class:
      // But be careful --- if we don't exactly match the name
      // in TClassTable, then we may trigger autoparsing.  Besides the
      // resource usage that implies, that can lead to crashes in dbg
      // builds due to cling bugs.
      std::string tn = Utils::getTypeName(*ti);
      if (tn.starts_with("std::vector<")) {
        tn.erase(0, 5);
      }
      std::string fac_class_name =
          "SG::AuxTypeVectorFactory<" + tn + ",allocator<" + tn;
      if (fac_class_name[fac_class_name.size() - 1] == '>') {
        fac_class_name += ' ';
      }
      fac_class_name += "> >";
 
      // Look for the dictionary of this type:
      ::TClass* fac_class = TClass::GetClass(fac_class_name.c_str());
      if (fac_class && fac_class->IsLoaded()) {
        ::TClass* base_class = ::TClass::GetClass("SG::IAuxTypeVectorFactory");
        if (base_class && base_class->IsLoaded()) {
          const Int_t offs = fac_class->GetBaseClassOffset(base_class);
          if (offs >= 0) {
            void* fac_vp = fac_class->New();
            if (fac_vp) {
              unsigned long tmp =
                  reinterpret_cast<unsigned long>(fac_vp) + offs;
              SG::IAuxTypeVectorFactory* fac =
                  reinterpret_cast<SG::IAuxTypeVectorFactory*>(tmp);
              registry.addFactory(
                  *ti, *fac->tiAlloc(),
                  std::unique_ptr<SG::IAuxTypeVectorFactory>(fac));
              auxid = registry.getAuxID(*ti, std::string{auxName}, "", flags,
                                        linked_auxid);
            }
          }
        }
      }
    }
 
    // If that didn't succeed, let's assign a generic factory to this type:
    if (auxid == SG::null_auxid && linked_auxid == SG::null_auxid) {
 
      // Construct the name of the vector type:
      std::string vec_class_name = "std::vector<" + Utils::getTypeName(*ti);
      if (vec_class_name[vec_class_name.size() - 1] == '>') {
        vec_class_name += ' ';
      }
      vec_class_name += '>';
 
      // Get the dictionary for the type:
      ::TClass* vec_class = ::TClass::GetClass(vec_class_name.c_str());
      if (vec_class && vec_class->IsLoaded()) {
        auto fac = std::make_unique<TAuxVectorFactory>(vec_class);
        if (fac->tiAlloc()) {
          const std::type_info* tiAlloc = fac->tiAlloc();
          registry.addFactory(*ti, *tiAlloc, std::move(fac));
        } else {
          std::string tiAllocName = fac->tiAllocName();
          registry.addFactory(*ti, tiAllocName, std::move(fac));
        }
        auxid = registry.getAuxID(*ti, std::string{auxName}, "",
                                  SG::AuxVarFlags::SkipNameCheck);
      } else {
        ::Warning("xAOD::TAuxStore::impl::setupAuxBranch",
                  "Couldn't find dictionary for type: %s",
                  vec_class_name.c_str());
      }
    }
 
    // Check if we succeeded:
    if (auxid == SG::null_auxid) {
      if (linked_auxid != SG::null_auxid) {
        ::Error("xAOD::TAuxStore::impl::setupAuxBranch",
                XAOD_MESSAGE("Dynamic ROOT vector factory not implemented for "
                             "linked types; branch "
                             "\"%s\""),
                br.GetName());
      } else {
        ::Error("xAOD::TAuxStore::impl::setupAuxBranch",
                XAOD_MESSAGE("Couldn't assign auxiliary ID to branch "
                             "\"%s\""),
                br.GetName());
      }
      return StatusCode::FAILURE;
    }
 
    // Remember the auxiliary ID:
    m_data.m_auxIDs.insert(auxid);
    return StatusCode::SUCCESS;
  }

Member Data Documentation

m_basketSize

int xAOD::TAuxStore::impl::m_basketSize = 2048

The basket size for the output branches.

Definition at line 794 of file TAuxStore.cxx.

m_branches

std::vector<std::unique_ptr<TBranchHandle> > xAOD::TAuxStore::impl::m_branches

Branches reading the various auxiliary variables.

Definition at line 807 of file TAuxStore.cxx.

m_branchesWritten

std::vector<bool> xAOD::TAuxStore::impl::m_branchesWritten

"Write status" of the different variables

Definition at line 809 of file TAuxStore.cxx.

m_data

Members& xAOD::TAuxStore::impl::m_data

Variables coming from AuxStoreBase.

Definition at line 791 of file TAuxStore.cxx.

m_inputScanned

bool xAOD::TAuxStore::impl::m_inputScanned = false

"Scan status" of the input TTree

Definition at line 804 of file TAuxStore.cxx.

m_inTree

::TTree* xAOD::TAuxStore::impl::m_inTree = nullptr

The TTree being read from.

Definition at line 799 of file TAuxStore.cxx.

m_missingBranches

std::vector<bool> xAOD::TAuxStore::impl::m_missingBranches

Mark branches we've found to be missing.

(Because TTree::GetBranch is very expensive.)

Definition at line 812 of file TAuxStore.cxx.

m_mutex

mutex_t xAOD::TAuxStore::impl::m_mutex

mutable

Mutex object used for multithreaded synchronisation.

Definition at line 815 of file TAuxStore.cxx.

m_outTree

::TTree* xAOD::TAuxStore::impl::m_outTree = nullptr

The TTree being written to.

Definition at line 801 of file TAuxStore.cxx.

m_splitLevel

int xAOD::TAuxStore::impl::m_splitLevel = 0

The split level for the output branches.

Definition at line 796 of file TAuxStore.cxx.

---

The documentation for this struct was generated from the following file:

• TAuxStore.cxx