xAOD::RAuxStore::impl Struct Reference

Collaboration diagram for xAOD::RAuxStore::impl:

Public Member Functions
StatusCode	scanInputTuple ()
	Scans the input ntuple for auxiliary data fields and sets up the necessary structures to access them. More...
const std::type_info *	auxFieldType (const ROOT::RFieldBase &field, std::string *expectedClassName=nullptr)
	This function retrieves the type information for a given auxiliary field. More...
StatusCode	setupAuxField (const ROOT::RFieldBase &field, std::string_view auxName)
	This function sets up an auxiliary field by determining its type and attempting to register it with the auxiliary type registry. More...

Public Attributes
Members &	m_data
	Variables coming from AuxStoreBase. More...
ROOT::RNTupleReader *	m_inTuple = nullptr
	The ntuple being read from. More...
ROOT::RNTupleWriter *	m_outTuple = nullptr
	The ntuple being written to. More...
bool	m_inputScanned = false
	"Scan status" of the input RNTuple More...
::Long64_t	m_entry
	The entry to load from the ntuple. More...
std::vector< std::unique_ptr< RFieldHandle > >	m_fields
	Fields containing the various auxiliary variables. More...
std::vector< bool >	m_fieldsWritten
	"Write status" of the different variables More...
std::vector< bool >	m_missingFields
	Mark fields we've found to be missing. More...
mutex_t	m_mutex
	Mutex object used for multithreaded synchronisation. More...

Detailed Description

Definition at line 249 of file RAuxStore.cxx.

Member Function Documentation

auxFieldType()

const std::type_info* xAOD::RAuxStore::impl::auxFieldType ( const ROOT::RFieldBase &  field, std::string *  expectedClassName = nullptr  )

inline

This function retrieves the type information for a given auxiliary field.

It uses the field's inspector to determine the type and handles cases where the expected class or collection proxy is not available.

Parameters

field	The field to get the type of
expectedClassName	The (optional) name of the expected (on disk) class

Returns

A pointer to the type information for the field

Definition at line 347 of file RAuxStore.cxx.

                                                                             {
 
    // Get the type name of the field. Not worrying about automatic schema
    // evolution for now.
    const std::string typeName = field.GetTypeName();
    ::TClass* expectedClass = ::TClass::GetClass(typeName.c_str());
    if (expectedClassName) {
      if (expectedClass) {
        *expectedClassName = expectedClass->GetName();
      } else {
        *expectedClassName = typeName;
      }
    }
 
    // 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 ((Utils::isPrimitiveType(typeName)) &&
        (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(typeName));
      }
    } else {
      if (!expectedClass) {
        ::Warning("xAOD::RAuxStore::impl::auxFieldType",
                  "Couldn't get the type of field \"%s\"",
                  field.GetFieldName().c_str());
      } else {
        ::TVirtualCollectionProxy* prox = expectedClass->GetCollectionProxy();
 
        if (!prox) {
          TClass* cl2 = details::lookupVectorType(*expectedClass);
          if (cl2) {
            prox = cl2->GetCollectionProxy();
          }
        }
 
        if (!prox) {
          ::Warning("xAOD::RAuxStore::impl::auxFieldType",
                    "Couldn't get the type of field \"%s\"",
                    field.GetFieldName().c_str());
        } else {
          if (prox->GetValueClass()) {
            ti = prox->GetValueClass()->GetTypeInfo();
          } else {
            ti = &(Utils::getTypeInfo(prox->GetType()));
          }
        }
      }
    }
 
    return ti;
  }

scanInputTuple()

StatusCode xAOD::RAuxStore::impl::scanInputTuple ( )

inline

Scans the input ntuple for auxiliary data fields and sets up the necessary structures to access them.

It ensures that the input ntuple is properly scanned and the auxiliary data fields are set up.

Returns

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

Definition at line 258 of file RAuxStore.cxx.

                              {
 
    // Check if an input ntuple is even available.
    if (!m_inTuple) {
      // 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;
    }
 
    // Iterate over all fields of the input ntuple.
    for (const ROOT::RFieldBase* field :
#if ROOT_VERSION_CODE >= ROOT_VERSION(6, 35, 0)
         m_inTuple->GetModel().GetConstFieldZero().GetConstSubfields()
#else
         m_inTuple->GetModel().GetConstFieldZero().GetSubFields()
#endif  // ROOT_VERSION_CODE >= ROOT_VERSION(6, 35, 0)
    ) {
 
      // Get the name of the current field.
      const std::string fieldName = field->GetQualifiedFieldName();
 
      // Look for static fields.
      if (m_data.m_topStore && (fieldName == m_data.m_prefix)) {
 
        // Loop over the sub-fields of this field.
        for (const ROOT::RFieldBase* subField :
#if ROOT_VERSION_CODE >= ROOT_VERSION(6, 35, 0)
             field->GetConstSubfields()
#else
             field->GetSubFields()
#endif  // ROOT_VERSION_CODE >= ROOT_VERSION(6, 35, 0)
        ) {
 
          // Get the name of this sub-field.
          const std::string subFieldName = subField->GetQualifiedFieldName();
          const std::string subAuxName =
              subFieldName.substr(subFieldName.find(".") + 1);
 
          // Skip this entry if it refers to a base class.
          if (subAuxName.starts_with("xAOD::") ||
              subAuxName.starts_with("SG::") ||
              subAuxName.starts_with("ILockable")) {
            continue;
          }
 
          // Set up this field.
          RETURN_CHECK("xAOD::RAuxStore::impl::scanInputNtuple",
                       setupAuxField(*subField, subAuxName));
        }
        // Don't check the rest of the loop's body:
        continue;
      }
 
      // if fieldname doesnt start with the value of m_dynPrefix, skip
      if (fieldName.starts_with(m_data.m_dynPrefix) == false) {
        continue;
      }
      if (fieldName == m_data.m_dynPrefix) {
        ::Error("xAOD::RAuxStore::impl::scanInputNtuple",
                "Dynamic field with empty name found on container: %s",
                m_data.m_prefix.c_str());
        continue;
      }
      // The auxiliary property name:
      const std::string auxName = fieldName.substr(fieldName.find(":") + 1);
      // Leave the rest up to the function that is shared with the
      // dynamic fields:
      RETURN_CHECK("xAOD::RAuxStore::scanInputNtuple",
                   setupAuxField(*field, auxName));
    }
 
    // the input was successfully scanned:
    m_inputScanned = true;
    return StatusCode::SUCCESS;
  }

setupAuxField()

StatusCode xAOD::RAuxStore::impl::setupAuxField ( const ROOT::RFieldBase &  field, std::string_view  auxName  )

inline

This function sets up an auxiliary field by determining its type and attempting to register it with the auxiliary type registry.

If the field type is not known, it tries to create a factory for the field's type. The function handles both static and dynamic fields and updates the set of known auxiliary IDs upon success.

Parameters

field	The field to set up
auxName	The name of the auxiliary property, extracted from the field's name

Returns

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

Definition at line 421 of file RAuxStore.cxx.

                                                   {
 
    // Get the (on disk) type of the field.
    std::string expectedClassName;
    const std::type_info* ti = auxFieldType(field, &expectedClassName);
    if (ti == nullptr) {
      // If we didn't find a type_info for the field, 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 fields.
    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 linkedAuxId = SG::null_auxid;
 
    if (SG::AuxTypeRegistry::isLinkedName(std::string{auxName})) {
      flags |= SG::AuxVarFlags::Linked;
    } else if (SG::AuxTypeRegistry::classNameHasLink(expectedClassName)) {
      const std::string linkedAttr =
          SG::AuxTypeRegistry::linkedName(std::string{auxName});
      const std::string linkedFieldName =
          SG::AuxTypeRegistry::linkedName(field.GetFieldName());
      const std::type_info* linkedTi = nullptr;
      if (::fieldExists(linkedFieldName, *m_inTuple)) {
        linkedTi =
            auxFieldType(m_inTuple->GetModel().GetConstField(linkedFieldName));
      }
      if (linkedTi) {
        linkedAuxId = registry.getAuxID(
            *linkedTi, linkedAttr, "",
            SG::AuxVarFlags::SkipNameCheck | SG::AuxVarFlags::Linked);
      }
      if (linkedAuxId == SG::null_auxid) {
        ::Error("xAOD::RAuxStore::setupAuxField",
                "Could not find linked variable for %s type %s", auxName.data(),
                expectedClassName.c_str());
      }
    }
 
    // Check for an auxiliary ID for this field:
    SG::auxid_t auxid =
        registry.getAuxID(*ti, std::string{auxName}, "", flags, linkedAuxId);
 
    // 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 typeName = Utils::getTypeName(*ti);
      if (typeName.starts_with("std::vector<"))
        typeName.erase(0, 5);
      std::string factoryClassName =
          "SG::AuxTypeVectorFactory<" + typeName + ",allocator<" + typeName;
      if (factoryClassName[factoryClassName.size() - 1] == '>') {
        factoryClassName += ' ';
      }
      factoryClassName += "> >";
 
      // Look for the dictionary of this type:
      ::TClass* factoryClass = TClass::GetClass(factoryClassName.c_str());
      if (factoryClass && factoryClass->IsLoaded()) {
        ::TClass* baseClass = ::TClass::GetClass("SG::IAuxTypeVectorFactory");
        if (baseClass && baseClass->IsLoaded()) {
          const Int_t offset = factoryClass->GetBaseClassOffset(baseClass);
          if (offset >= 0) {
            void* factoryVoidPointer = factoryClass->New();
            if (factoryVoidPointer) {
              unsigned long tmp =
                  reinterpret_cast<unsigned long>(factoryVoidPointer) + offset;
              SG::IAuxTypeVectorFactory* factory =
                  reinterpret_cast<SG::IAuxTypeVectorFactory*>(tmp);
              registry.addFactory(
                  *ti, *factory->tiAlloc(),
                  std::unique_ptr<SG::IAuxTypeVectorFactory>(factory));
              auxid = registry.getAuxID(*ti, std::string{auxName}, "", flags,
                                        linkedAuxId);
            }
          }
        }
      }
    }
 
    // If that didn't succeed, let's assign a generic factory to this type:
    if (auxid == SG::null_auxid && linkedAuxId == SG::null_auxid) {
      // Construct the name of the vector type:
      std::string vectorClassName = "std::vector<" + Utils::getTypeName(*ti);
      if (vectorClassName[vectorClassName.size() - 1] == '>') {
        vectorClassName += ' ';
      }
      vectorClassName += '>';
 
      // Get the dictionary for the type:
      ::TClass* vectorClass = ::TClass::GetClass(vectorClassName.c_str());
      if (vectorClass && vectorClass->IsLoaded()) {
        auto factory = std::make_unique<TAuxVectorFactory>(vectorClass);
        if (factory->tiAlloc()) {
          const std::type_info* tiAlloc = factory->tiAlloc();
          registry.addFactory(*ti, *tiAlloc, std::move(factory));
        } else {
          std::string tiAllocName = factory->tiAllocName();
          registry.addFactory(*ti, tiAllocName, std::move(factory));
        }
        auxid = registry.getAuxID(*ti, std::string{auxName}, "",
                                  SG::AuxVarFlags::SkipNameCheck);
      } else {
        ::Warning("xAOD::RAuxStore::setupAuxField",
                  "Couldn't find dictionary for type: %s",
                  vectorClassName.c_str());
      }
    }
 
    // Check if we succeeded:
    if (auxid == SG::null_auxid) {
      if (linkedAuxId != SG::null_auxid) {
        ::Error("xAOD::RAuxStore::setupAuxField",
                XAOD_MESSAGE("Dynamic ROOT vector factory not implemented for "
                             "linked types; field \"%s\""),
                field.GetFieldName().c_str());
      } else {
        ::Error("xAOD::RAuxStore::setupAuxField",
                XAOD_MESSAGE("Couldn't assign auxiliary ID to field \"%s\""),
                field.GetFieldName().c_str());
      }
      return StatusCode::FAILURE;
    }
 
    // Remember the auxiliary ID:
    m_data.m_auxIDs.insert(auxid);
    return StatusCode::SUCCESS;
  }

Member Data Documentation

m_data

Members& xAOD::RAuxStore::impl::m_data

Variables coming from AuxStoreBase.

Definition at line 567 of file RAuxStore.cxx.

m_entry

::Long64_t xAOD::RAuxStore::impl::m_entry

The entry to load from the ntuple.

Definition at line 578 of file RAuxStore.cxx.

m_fields

std::vector<std::unique_ptr<RFieldHandle> > xAOD::RAuxStore::impl::m_fields

Fields containing the various auxiliary variables.

Definition at line 581 of file RAuxStore.cxx.

m_fieldsWritten

std::vector<bool> xAOD::RAuxStore::impl::m_fieldsWritten

"Write status" of the different variables

Definition at line 583 of file RAuxStore.cxx.

m_inputScanned

bool xAOD::RAuxStore::impl::m_inputScanned = false

"Scan status" of the input RNTuple

Definition at line 575 of file RAuxStore.cxx.

m_inTuple

ROOT::RNTupleReader* xAOD::RAuxStore::impl::m_inTuple = nullptr

The ntuple being read from.

Definition at line 570 of file RAuxStore.cxx.

m_missingFields

std::vector<bool> xAOD::RAuxStore::impl::m_missingFields

Mark fields we've found to be missing.

Definition at line 585 of file RAuxStore.cxx.

m_mutex

mutex_t xAOD::RAuxStore::impl::m_mutex

mutable

Mutex object used for multithreaded synchronisation.

Definition at line 588 of file RAuxStore.cxx.

m_outTuple

ROOT::RNTupleWriter* xAOD::RAuxStore::impl::m_outTuple = nullptr

The ntuple being written to.

Definition at line 572 of file RAuxStore.cxx.

---

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

• RAuxStore.cxx