xAOD::RAuxStore Class Reference

"ROOT @c RNTuple implementation" of IAuxStore More...

#include <RAuxStore.h>

Inheritance diagram for xAOD::RAuxStore:

Collaboration diagram for xAOD::RAuxStore:

Classes
struct	impl

Public Types
enum class	EStructMode { kUndefinedStore = 0 , kContainerStore = 1 , kObjectStore = 2 }
	"Structural" modes of the object More...

Public Member Functions
	RAuxStore (std::string_view prefix="", bool topStore=true, EStructMode mode=EStructMode::kUndefinedStore)
	Constructor.
virtual	~RAuxStore ()
	Destructor.
virtual void	setPrefix (std::string_view prefix) override
	Set the object name prefix.
StatusCode	readFrom (ROOT::RNTupleReader &reader)
	Connect the object to an input RNTuple.
StatusCode	writeTo (ROOT::RNTupleWriter &writer)
	Add the variables of the store to an output RNTuple.
StatusCode	getEntry (std::int64_t entry, int getall=0)
	Get entry from the input RNTuple.
StatusCode	commitTo (ROOT::REntry &entry)
	Commit a new entry to the output RNTuple.
EStructMode	structMode () const
	Get what structure mode the object was constructed with.
void	setStructMode (EStructMode mode)
	Set the structure mode of the object to a new value.
const std::string &	prefix () const
	Get the currently configured object name prefix.
bool	isTopStore () const
	Check if the object is a "top store", or not.
void	setTopStore (bool value=true)
	Set whether the object should behave as a "top store" or not.
virtual void *	getData (auxid_t auxid, size_t size, size_t capacity)=0
	Return the data vector for one aux data item.
virtual void *	getDecoration (auxid_t auxid, size_t size, size_t capacity)=0
	Return the data vector for one aux data decoration item.
virtual bool	resize (size_t sz)=0
	Change the size of all aux data vectors.
virtual void	reserve (size_t sz)=0
	Change the capacity of all aux data vectors.
virtual void	shift (size_t pos, ptrdiff_t offs)=0
	Shift the elements of the container.
virtual bool	insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore=SG::auxid_set_t())=0
	Move all elements from other to this store.
virtual bool	setOption (auxid_t, const AuxDataOption &)
	Set an option for a given auxiliary variable.
Functions implementing the @c SG::IConstAuxStore interface
virtual const void *	getData (SG::auxid_t auxid) const override
	Get a pointer to a given array.
virtual const SG::IAuxTypeVector *	getVector (SG::auxid_t auxid) const override
	Return vector interface for one aux data item.
virtual const SG::auxid_set_t &	getAuxIDs () const override
	Get the types(names) of variables handled by this container.
virtual const SG::auxid_set_t &	getDecorIDs () const override
	Get the types(names) of decorations handled by this container.
virtual void *	getDecoration (SG::auxid_t auxid, std::size_t size, std::size_t capacity) override
	Get a pointer to a given array, creating the array if necessary.
virtual bool	isDecoration (SG::auxid_t auxid) const override
	Test if a variable is a decoration.
virtual void	lock () override
	Lock the object, and don't let decorations be added.
virtual bool	clearDecorations () override
	Remove the decorations added so far.
virtual void	lockDecoration (SG::auxid_t auxid) override
	Lock a decoration.
virtual std::size_t	size () const override
	Return the number of elements in the store.
virtual const SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) const override
	Return (const) interface for a linked variable.
virtual SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) override
	Return (non-const) interface for a linked variable.
Functions implementing the @c SG::IAuxStore interface
virtual void *	getData (SG::auxid_t auxid, std::size_t size, std::size_t capacity) override
	Get a pointer to a given array, creating the array if necessary.
virtual const SG::auxid_set_t &	getWritableAuxIDs () const override
	Return a set of writable data identifiers.
virtual bool	resize (std::size_t size) override
	Resize the arrays to a given size.
virtual void	reserve (std::size_t size) override
	Reserve a given size for the arrays.
virtual void	shift (std::size_t pos, std::ptrdiff_t offs) override
	Shift the contents of the stored arrays.
virtual bool	insertMove (std::size_t pos, SG::IAuxStore &other, const SG::auxid_set_t &ignore) override
	Insert contents of another store via move.
Functions implementing the SG::IAuxStoreIO interface
virtual const void *	getIOData (SG::auxid_t auxid) const override
	Get a pointer to the data being stored for one aux data item.
virtual const std::type_info *	getIOType (SG::auxid_t auxid) const override
	Return the type of the data to be stored for one aux data item.
virtual const SG::auxid_set_t &	getDynamicAuxIDs () const override
	Get the types(names) of variables created dynamically.
virtual void	selectAux (const std::set< std::string > &attributes)
	Select dynamic auxiliary attributes for writing.
virtual SG::auxid_set_t	getSelectedAuxIDs () const override
	Get the IDs of the selected aux variables.

Static Public Attributes
static constexpr bool	supportsThinning = true
	Mark that this type supports thinning operations.

Protected Types
using	mutex_t = AthContainers_detail::mutex
	Mutex type for multithread synchronization.
using	guard_t = AthContainers_detail::lock_guard<mutex_t>
	Guard type for multithreaded synchronisation.

Protected Member Functions
bool	isAuxIDSelected (SG::auxid_t auxid) const
	Check if an auxiliary variable is selected for ouput writing.

Protected Attributes
Members	m_data
	Member variables of the base class.

Private Attributes
std::unique_ptr< impl >	m_impl
	Pointer to the internal object.
AuxSelection	m_selection
	Object helping to select which auxiliary variables to write.
bool	m_locked = false
	Is this container locked?
mutex_t	m_mutex1
	Mutex objects used for multithreaded synchronisation.
mutex_t	m_mutex2

Functions implementing functionality for @c AuxStoreBase
virtual void	reset () override
	Tell the object that all branches will need to be re-read.
virtual bool	hasEntryFor (SG::auxid_t auxid) const override
	Check if a given variable is available from the input.
virtual StatusCode	getEntryFor (SG::auxid_t auxid) override
	Load a single variable from the input.
virtual bool	hasOutput () const override
	Check if an output is being written by the object.
virtual StatusCode	setupInputData (SG::auxid_t auxid) override
	Connect a variable to the input.
virtual StatusCode	setupOutputData (SG::auxid_t auxid) override
	Connect a variable to the output.
virtual const void *	getInputObject (SG::auxid_t auxid) const override
	Get a pointer to an input object, as it is in memory, for getIOData()
virtual const std::type_info *	getInputType (SG::auxid_t auxid) const override
	Get the type of an input object, for getIOType()

Detailed Description

"ROOT @c RNTuple implementation" of IAuxStore

Author

Mads Lildholdt Hansen mlha2.nosp@m.0@st.nosp@m.udent.nosp@m..aau.nosp@m..dk

Nikolaj Kofod Krogh nkrog.nosp@m.h20@.nosp@m.stude.nosp@m.nt.a.nosp@m.au.dk

Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Definition at line 38 of file RAuxStore.h.

Member Typedef Documentation

guard_t

using xAOD::details::AuxStoreBase::guard_t = AthContainers_detail::lock_guard<mutex_t>

protectedinherited

Guard type for multithreaded synchronisation.

Definition at line 206 of file AuxStoreBase.h.

mutex_t

using xAOD::details::AuxStoreBase::mutex_t = AthContainers_detail::mutex

protectedinherited

Mutex type for multithread synchronization.

Definition at line 204 of file AuxStoreBase.h.

Member Enumeration Documentation

EStructMode

enum class xAOD::details::AuxStoreBase::EStructMode

stronginherited

"Structural" modes of the object

Enumerator
kUndefinedStore	The structure mode is not defined.
kContainerStore	The object describes an entire container.
kObjectStore	The object describes a single object.

Definition at line 30 of file AuxStoreBase.h.

                         {
    kUndefinedStore = 0,  
    kContainerStore = 1,  
    kObjectStore = 2      
  };

Constructor & Destructor Documentation

RAuxStore()

xAOD::RAuxStore::RAuxStore	(	std::string_view	prefix = "",
		bool	topStore = true,
		EStructMode	mode = EStructMode::kUndefinedStore )

Constructor.

Definition at line 596 of file RAuxStore.cxx.

    : details::AuxStoreBase(topStore, mode),
      m_impl{std::make_unique<impl>(m_data)} {
 
  setPrefix(prefix);
}

~RAuxStore()

xAOD::RAuxStore::~RAuxStore ( )

virtualdefault

Destructor.

Member Function Documentation

clearDecorations()

bool xAOD::details::AuxStoreBase::clearDecorations ( )

overridevirtualinherited

Remove the decorations added so far.

Only works for transient decorations.

Implements SG::IConstAuxStore.

Definition at line 216 of file AuxStoreBase.cxx.

                                    {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // Clear the transient decorations:
  bool anycleared = false;
  if (m_data.m_transientStore) {
    SG::auxid_set_t old_id_set = m_data.m_transientStore->getAuxIDs();
 
    // Clear the decorations from the transient store:
    anycleared = m_data.m_transientStore->clearDecorations();
 
    // Now remove ids that were cleared.
    if (anycleared) {
      old_id_set -= m_data.m_transientStore->getAuxIDs();
      // old_id_set is now the set of ids that were cleared.
      m_data.m_auxIDs -= old_id_set;
      m_data.m_decorIDs.clear();
    }
  }
 
  // The decorations which are going into the output file, are here to stay.
  // Removing their IDs from the internal set would just cause more problems
  // in my mind than just leaving them be.
 
  return anycleared;
}

commitTo()

StatusCode xAOD::RAuxStore::commitTo

(

ROOT::REntry &

entry

)

Commit a new entry to the output RNTuple.

Definition at line 716 of file RAuxStore.cxx.

                                                {
 
  assert(m_impl);
 
  // Loop through all of the output variables.
  for (SG::auxid_t id : getSelectedAuxIDs()) {
    // Now connect the output entry to the variable.
    const std::string fieldName =
        std::format("{}{}", m_data.m_dynPrefix,
                    SG::AuxTypeRegistry::instance().getName(id));
    void* fieldPtr = const_cast<void*>(getIOData(id));
    if (fieldPtr) {
      entry.BindRawPtr(fieldName, fieldPtr);
    } else {
      entry.EmplaceNewValue(fieldName);
    }
  }
 
  // Return gracefully.
  return StatusCode::SUCCESS;
}

getAuxIDs()

const SG::auxid_set_t & xAOD::details::AuxStoreBase::getAuxIDs ( ) const

overridevirtualinherited

Get the types(names) of variables handled by this container.

Implements SG::IConstAuxStore.

Definition at line 106 of file AuxStoreBase.cxx.

                                                   {
 
  return m_data.m_auxIDs;
}

getData() [1/3]

virtual void * SG::IAuxStore::getData ( auxid_t auxid, size_t size, size_t capacity )

pure virtualinherited

Return the data vector for one aux data item.

Parameters

auxid	The identifier of the desired aux data item.
size	The current size of the container (in case the data item does not already exist).
capacity	The current capacity of the container (in case the data item does not already exist).

Each aux data item is stored as a vector, with one entry per entry in the owning container. This returns a pointer to the start of the vector.

If the data item does not exist, it should be created and initialized to default values. size and capacity give the size for the new aux data item vector.

If the container is locked, throw an exception.

Implemented in APRTest::AuxStore, RootAuxDynStore, SG::AuxStoreInternal, xAOD::AuxContainerBase, xAOD::AuxInfoBase, xAOD::ByteStreamAuxContainer_v1, and xAOD::ShallowAuxContainer.

getData() [2/3]

const void * xAOD::details::AuxStoreBase::getData ( SG::auxid_t auxid ) const

overridevirtualinherited

Get a pointer to a given array.

Implements SG::IConstAuxStore.

Definition at line 56 of file AuxStoreBase.cxx.

                                                       {
 
  const SG::IAuxTypeVector* v = getVector(auxid);
  if (v) {
    return v->toPtr();
  }
  return nullptr;
}

getData() [3/3]

void * xAOD::details::AuxStoreBase::getData ( SG::auxid_t auxid, std::size_t size, std::size_t capacity )

overridevirtualinherited

Get a pointer to a given array, creating the array if necessary.

Definition at line 308 of file AuxStoreBase.cxx.

                                                {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex2);
 
  // Remember the size:
  m_data.m_size = size;
 
  // Check if we want to write this variable to the output:
  if (!(isAuxIDSelected(auxid) && hasOutput())) {
    // Create the store only when necessary:
    if (!m_data.m_transientStore) {
      m_data.m_transientStore = std::make_unique<SG::AuxStoreInternal>(
          m_data.m_structMode == EStructMode::kObjectStore);
      if (m_locked) {
        m_data.m_transientStore->lock();
      }
    }
    // Let the transient store create the variable:
    std::size_t nids = m_data.m_transientStore->getAuxIDs().size();
    void* result = m_data.m_transientStore->getData(auxid, size, capacity);
    if (result && (nids != m_data.m_transientStore->getAuxIDs().size())) {
      m_data.m_auxIDs.insert(auxid);
    }
    // Return the address in the transient memory:
    return result;
  }
 
  // If the variable exists already, and this is a locked store, then
  // we are in trouble.
  if (m_locked && (auxid < m_data.m_vecs.size()) && m_data.m_vecs[auxid]) {
    if (!((auxid < m_data.m_isDecoration.size()) &&
          m_data.m_isDecoration[auxid])) {
      throw SG::ExcStoreLocked(auxid);
    }
  }
 
  // Connect this auxiliary variable just to the output:
  if (setupOutputData(auxid).isFailure()) {
    ::Error("xAOD::AuxStoreBase::getData",
            XAOD_MESSAGE("Failed to set up variable %s"),
            SG::AuxTypeRegistry::instance().getName(auxid).c_str());
    return nullptr;
  }
 
  // Check whether things make sense:
  if ((m_data.m_structMode == EStructMode::kObjectStore) && (size != 1)) {
    ::Error("xAOD::AuxStoreBase::getData",
            XAOD_MESSAGE("Branch creation requested with:"));
    ::Error("xAOD::AuxStoreBase::getData", XAOD_MESSAGE("  name = %s"),
            SG::AuxTypeRegistry::instance().getName(auxid).c_str());
    ::Error("xAOD::AuxStoreBase::getData", XAOD_MESSAGE("  size = %i"),
            static_cast<int>(size));
    ::Error("xAOD::AuxStoreBase::getData",
            XAOD_MESSAGE("  m_structMode = EStructMode::kObjectStore"));
    return nullptr;
  }
 
  // Make sure the variable is of the right size:
  m_data.m_vecs[auxid]->reserve(capacity);
  m_data.m_vecs[auxid]->resize(size);
 
  // Return the object:
  return m_data.m_vecs[auxid]->toPtr();
}

getDecoration() [1/2]

virtual void * SG::IConstAuxStore::getDecoration ( auxid_t auxid, size_t size, size_t capacity )

pure virtualinherited

Return the data vector for one aux data decoration item.

Parameters

auxid	The identifier of the desired aux data item.
size	The current size of the container (in case the data item does not already exist).
capacity	The current capacity of the container (in case the data item does not already exist).

Each aux data item is stored as a vector, with one entry per entry in the owning container. This returns a pointer to the start of the vector.

If the data item does not exist, it then it will be created and initialized with default values. If the container is locked, then the new item will be marked as a decoration. size and capacity give the size for the new aux data item vector.

If the data item already exists, then we return it if either the container is not locked or the item is marked as a decoration. Otherwise we throw an exception.

Implemented in RootAuxDynStore, SG::AuxStoreConstMem, SG::AuxStoreInternal, xAOD::AuxContainerBase, xAOD::AuxInfoBase, xAOD::ByteStreamAuxContainer_v1, xAOD::EventAuxInfo_v1, xAOD::EventAuxInfo_v2, xAOD::EventAuxInfo_v3, xAOD::EventInfoAuxContainer_v1, and xAOD::ShallowAuxContainer.

getDecoration() [2/2]

void * xAOD::details::AuxStoreBase::getDecoration ( SG::auxid_t auxid, std::size_t size, std::size_t capacity )

overridevirtualinherited

Get a pointer to a given array, creating the array if necessary.

Definition at line 116 of file AuxStoreBase.cxx.

                                                      {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // Remember the requested size:
  m_data.m_size = size;
 
  // If this is a locked object, deal with it correctly:
  if (m_locked) {
    // If the variable exists already and it's a decoration, then let's
    // give it back.
    if ((auxid < m_data.m_vecs.size()) && m_data.m_vecs[auxid] &&
        (auxid < m_data.m_isDecoration.size() &&
         m_data.m_isDecoration[auxid])) {
      // Things look okay...
      m_data.m_vecs[auxid]->reserve(capacity);
      m_data.m_vecs[auxid]->resize(size);
      return m_data.m_vecs[auxid]->toPtr();
    }
    // If it's in the transient store already, return it from there.
    // Since in a locked store *everything* is a decoration in the
    // transient store.
    if (m_data.m_transientStore &&
        m_data.m_transientStore->getAuxIDs().test(auxid)) {
      return m_data.m_transientStore->getDecoration(auxid, size, capacity);
    }
    // If we know this auxiliary ID, but it was not found as a decoration
    // by the previous checks, then we're in trouble.
    if (m_data.m_auxIDs.test(auxid)) {
      throw SG::ExcStoreLocked(auxid);
    }
  }
 
  // Check if we want to write this variable to the output:
  if (!(isAuxIDSelected(auxid) && hasOutput())) {
 
    // Create the store only when necessary:
    if (!m_data.m_transientStore) {
      m_data.m_transientStore = std::make_unique<SG::AuxStoreInternal>(
          m_data.m_structMode == EStructMode::kObjectStore);
      if (m_locked) {
        m_data.m_transientStore->lock();
      }
    }
    // Let the transient store create the decoration:
    const std::size_t nids = m_data.m_transientStore->getAuxIDs().size();
    void* result =
        m_data.m_transientStore->getDecoration(auxid, size, capacity);
    if (result && (nids != m_data.m_transientStore->getAuxIDs().size())) {
      if (m_data.m_transientStore->isDecoration(auxid)) {
        m_data.m_decorIDs.insert(auxid);
      }
      std::atomic_thread_fence( std::memory_order_seq_cst );
      m_data.m_auxIDs.insert(auxid);
    }
    // Return the memory address from the transient store:
    return result;
  }
 
  // Doesn't exist yet. So let's make it:
  if (m_locked) {
    // If the container is locked, remember that this is a decoration:
    if (m_data.m_isDecoration.size() <= auxid) {
      m_data.m_isDecoration.resize(auxid + 1);
    }
    m_data.m_isDecoration[auxid] = true;
    m_data.m_decorIDs.insert(auxid);
    std::atomic_thread_fence( std::memory_order_seq_cst );
  }
  void* result = getData(auxid, size, capacity);
 
  // Return the pointer made by getData(...):
  return result;
}

getDecorIDs()

const SG::auxid_set_t & xAOD::details::AuxStoreBase::getDecorIDs ( ) const

overridevirtualinherited

Get the types(names) of decorations handled by this container.

Implements SG::IConstAuxStore.

Definition at line 111 of file AuxStoreBase.cxx.

                                                     {
 
  return m_data.m_decorIDs;
}

getDynamicAuxIDs()

const SG::auxid_set_t & xAOD::details::AuxStoreBase::getDynamicAuxIDs ( ) const

overridevirtualinherited

Get the types(names) of variables created dynamically.

Implements SG::IAuxStoreIO.

Definition at line 617 of file AuxStoreBase.cxx.

                                                          {
 
  // All the auxiliary decorations handled by this object are considered
  // dynamic:
  return getAuxIDs();
}

getEntry()

StatusCode xAOD::RAuxStore::getEntry	(	std::int64_t	entry,
		int	getall = 0 )

Get entry from the input RNTuple.

Definition at line 667 of file RAuxStore.cxx.

                                                           {
 
  assert(m_impl);
 
  // Guard against multi-threaded execution:
  guard_t guard(m_impl->m_mutex);
 
  m_impl->m_entry = entry;
 
  // Reset the transient store. TEvent::fill() calls this function with
  // getall==99. When that is happening, we need to keep the transient
  // store still around. Since the user may want to interact with the
  // object after it was written out. (And since TEvent::fill() asks for
  // the transient decorations after calling getEntry(...).)
  if (m_data.m_transientStore && (getall != 99)) {
    // Remove the transient auxiliary IDs from the internal list:
    m_data.m_auxIDs -= m_data.m_transientStore->getAuxIDs();
    m_data.m_decorIDs -= m_data.m_transientStore->getDecorIDs();
    // Delete the object:
    m_data.m_transientStore.reset();
  }
 
  // Now remove the IDs of the decorations that are getting persistified:
  if (getall != 99) {
    for (SG::auxid_t auxid = 0; auxid < m_data.m_isDecoration.size(); ++auxid) {
      if (!m_data.m_isDecoration[auxid]) {
        continue;
      }
      m_data.m_auxIDs.erase(auxid);
      m_data.m_decorIDs.erase(auxid);
    }
  }
 
  // If we don't need everything loaded, return now:
  if (!getall) {
    return StatusCode::SUCCESS;
  }
 
  // Get all the variables at once:
  for (auto& field : m_impl->m_fields) {
    if (field) {
      RETURN_CHECK("xAOD::RAuxStore::getEntry", field->getEntry(entry));
    }
  }
 
  // Return gracefully.
  return StatusCode::SUCCESS;
}

getEntryFor()

StatusCode xAOD::RAuxStore::getEntryFor ( SG::auxid_t auxid )

overrideprivatevirtual

Load a single variable from the input.

Implements xAOD::details::AuxStoreBase.

Definition at line 756 of file RAuxStore.cxx.

                                                 {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_impl->m_mutex);
 
  assert(m_impl);
  assert(m_impl->m_fields.size() > auxid);
  assert(m_impl->m_fields[auxid]);
  RETURN_CHECK("xAOD::RAuxStore::getEntryFor",
               m_impl->m_fields[auxid]->getEntry(m_impl->m_entry));
  return StatusCode::SUCCESS;
}

getInputObject()

const void * xAOD::RAuxStore::getInputObject ( SG::auxid_t auxid ) const

overrideprivatevirtual

Get a pointer to an input object, as it is in memory, for getIOData()

Implements xAOD::details::AuxStoreBase.

Definition at line 1126 of file RAuxStore.cxx.

                                                           {
 
  assert(m_impl);
  assert(m_impl->m_fields.size() > auxid);
  assert(m_impl->m_fields[auxid]);
  return m_impl->m_fields[auxid]->objectPtr();
}

getInputType()

const std::type_info * xAOD::RAuxStore::getInputType ( SG::auxid_t auxid ) const

overrideprivatevirtual

Get the type of an input object, for getIOType()

Implements xAOD::details::AuxStoreBase.

Definition at line 1134 of file RAuxStore.cxx.

                                                                 {
 
  assert(m_impl);
  assert(m_impl->m_fields.size() > auxid);
  assert(m_impl->m_fields[auxid]);
  return m_impl->m_fields[auxid]->typeInfo();
}

getIOData()

const void * xAOD::details::AuxStoreBase::getIOData ( SG::auxid_t auxid ) const

overridevirtualinherited

Get a pointer to the data being stored for one aux data item.

Implements SG::IAuxStoreIO.

Definition at line 519 of file AuxStoreBase.cxx.

                                                         {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  auto this_nc ATLAS_THREAD_SAFE =
      const_cast<AuxStoreBase*>(this);  // locked above
 
  // If the variable is coming from the input, and is connected to already.
  if (hasEntryFor(auxid)) {
    if (!this_nc->getEntryFor(auxid).isSuccess()) {
      ::Error("xAOD::AuxStoreBase::getIOData",
              XAOD_MESSAGE("Couldn't read in variable %s"),
              SG::AuxTypeRegistry::instance().getName(auxid).c_str());
      return nullptr;
    }
    return getInputObject(auxid);
  }
 
  // Check if it's in the transient store:
  if (m_data.m_transientStore &&
      m_data.m_transientStore->getAuxIDs().test(auxid)) {
    return m_data.m_transientStore->getIOData(auxid);
  }
 
  // If not, try connecting to it now:
  if (!this_nc->setupInputData(auxid).isSuccess()) {
    // This is not actually an error condition anymore. We can end up here
    // when we decorate constant objects coming from the input file, but
    // on one event we can't set any decorations. For instance when the
    // input container is empty. In that case the object will still list
    // the auxiliary ID belonging to that decoration as being available,
    // but it really isn't.
    //
    // Later on it might be needed to tweak the logic of all of this, but
    // for now just silently returning 0 seems to do the right thing.
    return nullptr;
  }
 
  // Now we should know this variable:
  if (!hasEntryFor(auxid)) {
    ::Fatal("xAOD::AuxStoreBase::getIOData",
            XAOD_MESSAGE("Internal logic error detected"));
    return nullptr;
  }
 
  // Make sure that the right payload is in memory:
  if (!this_nc->getEntryFor(auxid).isSuccess()) {
    ::Error("xAOD::AuxStoreBase::getIOData",
            XAOD_MESSAGE("Couldn't read in variable %s"),
            SG::AuxTypeRegistry::instance().getName(auxid).c_str());
    return nullptr;
  }
 
  // Return the pointer.
  return getInputObject(auxid);
}

getIOType()

const std::type_info * xAOD::details::AuxStoreBase::getIOType ( SG::auxid_t auxid ) const

overridevirtualinherited

Return the type of the data to be stored for one aux data item.

Implements SG::IAuxStoreIO.

Definition at line 578 of file AuxStoreBase.cxx.

                                                                 {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // If the variable is connected to already:
  if (hasEntryFor(auxid)) {
    return getInputType(auxid);
  }
 
  // Check if it's in the transient store:
  if (m_data.m_transientStore &&
      m_data.m_transientStore->getAuxIDs().test(auxid)) {
    return m_data.m_transientStore->getIOType(auxid);
  }
 
  // If not, try connecting to it now:
  auto this_nc ATLAS_THREAD_SAFE =
      const_cast<AuxStoreBase*>(this);  // locked above
  if (!this_nc->setupInputData(auxid).isSuccess()) {
    ::Error("xAOD::AuxStoreBase::getIOType",
            XAOD_MESSAGE("Couldn't connect to auxiliary variable "
                         "%i %s"),
            static_cast<int>(auxid),
            SG::AuxTypeRegistry::instance().getName(auxid).c_str());
    return nullptr;
  }
 
  // Now we should know this variable:
  if (!hasEntryFor(auxid)) {
    ::Fatal("xAOD::AuxStoreBase::getIOType",
            XAOD_MESSAGE("Internal logic error detected"));
    return nullptr;
  }
 
  // Return the type info:
  return getInputType(auxid);
}

getSelectedAuxIDs()

SG::auxid_set_t xAOD::details::AuxStoreBase::getSelectedAuxIDs ( ) const

overridevirtualinherited

Get the IDs of the selected aux variables.

Reimplemented from SG::IAuxStoreIO.

Definition at line 632 of file AuxStoreBase.cxx.

                                                    {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
  // Leave the calculation up to the internal object:
  return m_selection.getSelectedAuxIDs(m_data.m_auxIDs);
}

getVector()

const SG::IAuxTypeVector * xAOD::details::AuxStoreBase::getVector ( SG::auxid_t auxid ) const

overridevirtualinherited

Return vector interface for one aux data item.

Implements SG::IConstAuxStore.

Definition at line 65 of file AuxStoreBase.cxx.

                                                                     {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // Check if the transient store already handles this variable:
  if (m_data.m_transientStore &&
      (m_data.m_transientStore->getAuxIDs().test(auxid))) {
    return m_data.m_transientStore->getVector(auxid);
  }
 
  // Access the object through a non-const pointer. This is "safe" because
  // of the mutex lock above.
  auto this_nc ATLAS_THREAD_SAFE = const_cast<AuxStoreBase*>(this);
 
  // Connect this auxiliary variable both to the input and output
  // if needed:
  if ((auxid >= m_data.m_vecs.size()) || (!m_data.m_vecs[auxid])) {
    if ((!this_nc->setupInputData(auxid).isSuccess()) ||
        (!this_nc->setupOutputData(auxid).isSuccess())) {
      return nullptr;
    }
  }
 
  // Make sure the variable is up to date:
  if (this_nc->getEntryFor(auxid).isSuccess() == false) {
    ::Error("xAOD::AuxStoreBase::getVector",
            XAOD_MESSAGE("Couldn't read in variable %s"),
            SG::AuxTypeRegistry::instance().getName(auxid).c_str());
    return nullptr;
  }
 
  // Let the AuxTypeVector object know that the std::vector that it manages
  // has changed.   (This updates the cached span.)
  SG::IAuxTypeVector* vec = m_data.m_vecs[auxid].get();
  vec->resize (vec->size());
 
  // Return the pointer to the object:
  return vec;
}

getWritableAuxIDs()

const SG::auxid_set_t & xAOD::details::AuxStoreBase::getWritableAuxIDs ( ) const

overridevirtualinherited

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 375 of file AuxStoreBase.cxx.

                                                           {
 
  return getAuxIDs();
}

hasEntryFor()

bool xAOD::RAuxStore::hasEntryFor ( SG::auxid_t auxid ) const

overrideprivatevirtual

Check if a given variable is available from the input.

Implements xAOD::details::AuxStoreBase.

Definition at line 750 of file RAuxStore.cxx.

                                                 {
 
  assert(m_impl);
  return ((m_impl->m_fields.size() > auxid) && m_impl->m_fields[auxid]);
}

hasOutput()

bool xAOD::RAuxStore::hasOutput ( ) const

overrideprivatevirtual

Check if an output is being written by the object.

Implements xAOD::details::AuxStoreBase.

Definition at line 769 of file RAuxStore.cxx.

                                {
 
  assert(m_impl);
  return (m_impl->m_outTuple != nullptr);
}

insertMove() [1/2]

virtual bool SG::IAuxStore::insertMove ( size_t pos, IAuxStore & other, const SG::auxid_set_t & ignore = SG::auxid_set_t() )

pure virtualinherited

Move all elements from other to this store.

Parameters

pos	The starting index of the insertion.
other	Store from which to do the move.
ignore	Set of variables that should not be added to the store.

Let len be the size of other. The store will be increased in size by len elements, with the elements at pos being copied to pos+len. Then, for each auxiliary variable, the entire contents of that variable for other will be moved to this store at index pos. This will be done via move semantics if possible; otherwise, it will be done with a copy. Variables present in this store but not in other will have the corresponding elements default-initialized. Variables in other but not in this store will be added unless they are in ignore.

Returns true if it is known that none of the vectors' memory moved, false otherwise.

Implemented in SG::AuxStoreInternal.

insertMove() [2/2]

bool xAOD::details::AuxStoreBase::insertMove ( std::size_t pos, SG::IAuxStore & other, const SG::auxid_set_t & ignore )

overridevirtualinherited

Insert contents of another store via move.

Definition at line 469 of file AuxStoreBase.cxx.

                                                              {
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // A sanity check:
  if (m_data.m_structMode == EStructMode::kObjectStore) {
    ::Error("xAOD::AuxStoreBase::insertMove",
            XAOD_MESSAGE("Should not have been called for single-object "
                         "store"));
    return false;
  }
 
  bool nomove = true;
  std::size_t other_size = other.size();
 
  SG::auxid_set_t ignore = ignore_in;
 
  for (SG::auxid_t id : m_data.m_auxIDs) {
    SG::IAuxTypeVector* v_dst = nullptr;
    if (id < m_data.m_vecs.size()) {
      v_dst = m_data.m_vecs[id].get();
    }
    if (v_dst && !v_dst->isLinked()) {
      ignore.insert(id);
      if (other.getData(id)) {
        void* src_ptr = other.getData(id, other_size, other_size);
        if (src_ptr) {
          if (!v_dst->insertMove(pos, src_ptr, 0, other_size, other)) {
            nomove = false;
          }
        }
      } else {
        const void* orig = v_dst->toPtr();
        v_dst->shift(pos, other_size);
        if (orig != v_dst->toPtr()) {
          nomove = false;
        }
      }
    }
  }
 
  if (m_data.m_transientStore) {
    if (!m_data.m_transientStore->insertMove(pos, other, ignore))
      nomove = false;
  }
 
  return nomove;
}

isAuxIDSelected()

bool xAOD::details::AuxStoreBase::isAuxIDSelected ( SG::auxid_t auxid ) const

protectedinherited

Check if an auxiliary variable is selected for ouput writing.

This is a tricky one.

The function can't just rely on getSelectedAuxIDs, as the aux ID received here may be a new ID that the object doesn't yet know about. So we have no other choice but to check this ID explicitly.

@apram auxid The auxiliary ID that should be checked

Returns

true if the variable needs to be written out, false if not

Definition at line 648 of file AuxStoreBase.cxx.

                                                        {
 
  // A temporary object:
  SG::auxid_set_t auxids;
  auxids.insert(auxid);
 
  // Check if the auxid is returned as a selected ID:
  return m_selection.getSelectedAuxIDs(auxids).size();
}

isDecoration()

bool xAOD::details::AuxStoreBase::isDecoration ( SG::auxid_t auxid ) const

overridevirtualinherited

Test if a variable is a decoration.

Implements SG::IConstAuxStore.

Definition at line 193 of file AuxStoreBase.cxx.

                                                     {
  if (m_locked) {
    if (auxid < m_data.m_isDecoration.size() && m_data.m_isDecoration[auxid]) {
      return true;
    }
    if (m_data.m_transientStore) {
      return m_data.m_transientStore->isDecoration(auxid);
    }
  }
  return false;
}

isTopStore()

bool xAOD::details::AuxStoreBase::isTopStore ( ) const

inherited

Check if the object is a "top store", or not.

Definition at line 45 of file AuxStoreBase.cxx.

                                    {
 
  return m_data.m_topStore;
}

linkedVector() [1/2]

const SG::IAuxTypeVector * xAOD::details::AuxStoreBase::linkedVector ( SG::auxid_t auxid ) const

overridevirtualinherited

Return (const) interface for a linked variable.

Reimplemented from SG::IConstAuxStore.

Definition at line 281 of file AuxStoreBase.cxx.

                                                                        {
  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
  SG::auxid_t linked_id = r.linkedVariable(auxid);
  guard_t guard(m_mutex1);
  if (linked_id < m_data.m_vecs.size()) {
    return m_data.m_vecs[linked_id].get();
  }
  if (m_data.m_transientStore) {
    return CxxUtils::as_const_ptr(m_data.m_transientStore.get())
        ->linkedVector(auxid);
  }
  return nullptr;
}

linkedVector() [2/2]

SG::IAuxTypeVector * xAOD::details::AuxStoreBase::linkedVector ( SG::auxid_t auxid )

overridevirtualinherited

Return (non-const) interface for a linked variable.

Reimplemented from SG::IAuxStore.

Definition at line 295 of file AuxStoreBase.cxx.

                                                            {
  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
  SG::auxid_t linked_id = r.linkedVariable(auxid);
  guard_t guard(m_mutex1);
  if (linked_id < m_data.m_vecs.size()) {
    return m_data.m_vecs[linked_id].get();
  }
  if (m_data.m_transientStore) {
    return m_data.m_transientStore->linkedVector(auxid);
  }
  return nullptr;
}

lock()

void xAOD::details::AuxStoreBase::lock ( )

overridevirtualinherited

Lock the object, and don't let decorations be added.

Implements SG::IConstAuxStore.

Definition at line 205 of file AuxStoreBase.cxx.

                        {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  m_locked = true;
  if (m_data.m_transientStore) {
    m_data.m_transientStore->lock();
  }
}

lockDecoration()

void xAOD::details::AuxStoreBase::lockDecoration ( SG::auxid_t auxid )

overridevirtualinherited

Lock a decoration.

Implements SG::IConstAuxStore.

Definition at line 246 of file AuxStoreBase.cxx.

                                                 {
  if (m_data.m_transientStore) {
    m_data.m_transientStore->lockDecoration(auxid);
  }
  m_data.m_decorIDs.erase(auxid);
}

prefix()

const std::string & xAOD::details::AuxStoreBase::prefix ( ) const

inherited

Get the currently configured object name prefix.

Definition at line 40 of file AuxStoreBase.cxx.

                                            {
 
  return m_data.m_prefix;
}

readFrom()

StatusCode xAOD::RAuxStore::readFrom

(

ROOT::RNTupleReader &

reader

)

Connect the object to an input RNTuple.

This function is called by the infrastructure to connect the object to an input RNTuple whenever a new input file is opened.

Parameters

reader

The reader object set up by a parent object

Returns

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

Definition at line 619 of file RAuxStore.cxx.

                                                        {
 
  assert(m_impl);
 
  // Make sure that everything will be re-read after this:
  reset();
 
  // We will need to check again which branches are available:
  m_impl->m_missingFields.clear();
 
  // Remember the tree:
  m_impl->m_inTuple = &reader;
 
  // Catalogue all the branches:
  RETURN_CHECK("xAOD::RAuxStore::readFrom", m_impl->scanInputTuple());
 
  // Return gracefully.
  return StatusCode::SUCCESS;
}

reserve() [1/2]

virtual void SG::IAuxStore::reserve ( size_t sz )

pure virtualinherited

Change the capacity of all aux data vectors.

Parameters

sz	The new capacity.

This should be called when the capacity of the container changes (by reserve). This should change the capacity for the vectors for all aux data items.

Implemented in SG::AuxStoreInternal, xAOD::AuxContainerBase, xAOD::AuxInfoBase, xAOD::ByteStreamAuxContainer_v1, and xAOD::ShallowAuxContainer.

reserve() [2/2]

void xAOD::details::AuxStoreBase::reserve ( std::size_t size )

overridevirtualinherited

Reserve a given size for the arrays.

Definition at line 413 of file AuxStoreBase.cxx.

                                         {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // A sanity check:
  if ((m_data.m_structMode == EStructMode::kObjectStore) && (size != 1)) {
    ::Error("xAOD::AuxStoreBase::reserve",
            XAOD_MESSAGE("size = %i for single-object store"),
            static_cast<int>(size));
    return;
  }
 
  for (auto& v : m_data.m_vecs) {
    if (v && !v->isLinked()) {
      v->reserve(size);
    }
  }
 
  if (m_data.m_transientStore) {
    m_data.m_transientStore->reserve(size);
  }
}

reset()

void xAOD::RAuxStore::reset ( )

overridevirtual

Tell the object that all branches will need to be re-read.

Implements xAOD::details::AuxStoreBase.

Definition at line 738 of file RAuxStore.cxx.

                      {
 
  assert(m_impl);
 
  for (auto& field : m_impl->m_fields) {
    if (field) {
      field->reset();
    }
  }
  m_impl->m_inputScanned = false;
}

resize() [1/2]

virtual bool SG::IAuxStore::resize ( size_t sz )

pure virtualinherited

Change the size of all aux data vectors.

Parameters

sz	The new size.

This should be called when the size of the container changes. This should resize the vectors for all aux data items.

If the size of the container grows, the new elements should be default-initialized; if it shrinks, destructors should be run as appropriate.

Should return true if it is known that none of the data pointers changed (and thus the cache does not need to be cleared), false otherwise.

Implemented in SG::AuxStoreInternal, xAOD::AuxContainerBase, xAOD::AuxInfoBase, xAOD::ByteStreamAuxContainer_v1, and xAOD::ShallowAuxContainer.

resize() [2/2]

bool xAOD::details::AuxStoreBase::resize ( std::size_t size )

overridevirtualinherited

Resize the arrays to a given size.

Definition at line 380 of file AuxStoreBase.cxx.

                                        {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // A sanity check:
  if ((m_data.m_structMode == EStructMode::kObjectStore) && (size != 1)) {
    ::Error("xAOD::AuxStoreBase::resize",
            XAOD_MESSAGE("size = %i for single-object store"),
            static_cast<int>(size));
    return false;
  }
 
  // Remember the new size:
  m_data.m_size = size;
 
  bool nomoves = true;
  for (auto& v : m_data.m_vecs) {
    if (v && !v->isLinked()) {
      if (!v->resize(size)) {
        nomoves = false;
      }
    }
  }
  if (m_data.m_transientStore) {
    if (!m_data.m_transientStore->resize(size)) {
      nomoves = false;
    }
  }
 
  return nomoves;
}

selectAux()

void xAOD::details::AuxStoreBase::selectAux ( const std::set< std::string > & attributes )

virtualinherited

Select dynamic auxiliary attributes for writing.

Definition at line 625 of file AuxStoreBase.cxx.

                                                                {
 
  guard_t guard(m_mutex1);
  m_selection.selectAux(attributes);
}

setOption()

virtual bool SG::IAuxStore::setOption ( auxid_t , const AuxDataOption &  )

inlinevirtualinherited

Set an option for a given auxiliary variable.

Parameters

auxid	The identifier of the desired aux data item.
option	The option to set.

The interpretation of the option depends on the particular representation of the variable.

Returns true if the option setting was successful; false otherwise.

Reimplemented in SG::AuxStoreInternal, xAOD::AuxContainerBase, and xAOD::AuxInfoBase.

Definition at line 173 of file IAuxStore.h.

  { return false; }

setPrefix()

void xAOD::RAuxStore::setPrefix ( std::string_view prefix )

overridevirtual

Set the object name prefix.

Implements xAOD::details::AuxStoreBase.

Definition at line 605 of file RAuxStore.cxx.

                                               {
 
  m_data.m_prefix = prefix;
  m_data.m_dynPrefix = Utils::dynFieldPrefix(m_data.m_prefix);
  reset();
}

setStructMode()

void xAOD::details::AuxStoreBase::setStructMode ( EStructMode mode )

inherited

Set the structure mode of the object to a new value.

Definition at line 34 of file AuxStoreBase.cxx.

                                                 {
 
  m_data.m_structMode = mode;
  reset();
}

setTopStore()

void xAOD::details::AuxStoreBase::setTopStore ( bool value = true )

inherited

Set whether the object should behave as a "top store" or not.

Definition at line 50 of file AuxStoreBase.cxx.

                                         {
 
  m_data.m_topStore = value;
  reset();
}

setupInputData()

StatusCode xAOD::RAuxStore::setupInputData ( SG::auxid_t auxid )

overrideprivatevirtual

Connect a variable to the input.

This internal function takes care of connecting to an individual (sub-)field in the input file for a given auxiliary variable.

Parameters

auxid

The ID of the variable to connect to

Returns

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

Implements xAOD::details::AuxStoreBase.

Definition at line 782 of file RAuxStore.cxx.

                                                    {
 
  // Return right away if we already know that the field is missing.
  if ((auxid < m_impl->m_missingFields.size()) &&
      m_impl->m_missingFields[auxid]) {
    return StatusCode::RECOVERABLE;
  }
 
  // We may call this function without an input being used. That's not an
  // error either.
  if (m_impl->m_inTuple == nullptr) {
    return StatusCode::RECOVERABLE;
  }
 
  // Make sure the internal storage is large enough:
  if (m_data.m_vecs.size() <= auxid) {
    m_data.m_vecs.resize(auxid + 1);
  }
  if (m_impl->m_fields.size() <= auxid) {
    m_impl->m_fields.resize(auxid + 1);
  }
 
  // Check if we need to do anything. Remember, output-only variables don't
  // have an associated RFieldHandle. To tell the caller that no input is
  // actually available for the variable (only an output), use a different
  // return value.
  if (m_data.m_vecs[auxid]) {
    return (m_impl->m_fields[auxid] ? StatusCode::SUCCESS
                                    : StatusCode::RECOVERABLE);
  }
 
  // Convenience access to the registry.
  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  // Get the property name:
  const std::string statFieldName =
      std::format("{}{}", m_data.m_prefix, r.getName(auxid));
  const std::string dynFieldName =
      std::format("{}{}", m_data.m_dynPrefix, r.getName(auxid));
 
  // Check if the field exists:
  std::string fieldName = statFieldName;
  ROOT::DescriptorId_t fieldId;
  if ((fieldId = m_impl->m_inTuple->GetDescriptor().FindFieldId(
           statFieldName)) == std::numeric_limits<unsigned long>::max()) {
    if ((fieldId = m_impl->m_inTuple->GetDescriptor().FindFieldId(
             dynFieldName)) == std::numeric_limits<unsigned long>::max()) {
      // Remember that the field is missing.
      if (m_impl->m_missingFields.size() <= auxid) {
        m_impl->m_missingFields.resize(auxid + 1);
      }
      m_impl->m_missingFields[auxid] = true;
      // The field doesn't exist, but this is not an error per se.
      // The user may just be calling isAvailable(...) on the variable.
      return StatusCode::RECOVERABLE;
    }
    // We have a dynamic field:
    fieldName = std::move(dynFieldName);
  }
 
  // Get the object describing this field.
  const ROOT::RFieldDescriptor& fieldDesc =
      m_impl->m_inTuple->GetDescriptor().GetFieldDescriptor(fieldId);
 
  // Check if it's a "primitive field":
  const bool primitiveField = Utils::isPrimitiveType(fieldDesc.GetTypeName());
  // Check if it's a "container field":
  const bool containerField =
      (primitiveField ? false : isContainerField(fieldDesc, auxid));
 
  // Set the structure mode if it has not been defined externally:
  if (m_data.m_structMode == EStructMode::kUndefinedStore) {
    m_data.m_structMode = (containerField ? EStructMode::kContainerStore
                                          : EStructMode::kObjectStore);
  }
 
  // Check that the branch type makes sense:
  if ((containerField &&
       (m_data.m_structMode != EStructMode::kContainerStore) &&
       !r.isLinked(auxid)) ||
      ((!containerField) &&
       (m_data.m_structMode != EStructMode::kObjectStore))) {
    ::Error("xAOD::RAuxStore::setupInputData",
            XAOD_MESSAGE("Field type and requested structure mode "
                         "differ for field: %s"),
            fieldName.c_str());
    return StatusCode::FAILURE;
  }
 
  // Get the property type:
  const std::type_info* fieldType = nullptr;
  if (details::isRegisteredType(auxid)) {
    // Get the type from the auxiliary type registry:
    fieldType = (containerField ? r.getVecType(auxid) : r.getType(auxid));
  } else {
    // Get the type from the input field itself:
    TClass* clDummy = ::TClass::GetClass(fieldDesc.GetTypeName().c_str());
    fieldType = (clDummy ? clDummy->GetTypeInfo()
                         : &(Utils::getTypeInfo(fieldDesc.GetTypeName())));
  }
  if (!fieldType) {
    ::Error("xAOD::RAuxStore::setupInputData",
            XAOD_MESSAGE("Can't read/copy variable %s (%s)"), fieldName.c_str(),
            fieldDesc.GetTypeName().c_str());
    return StatusCode::RECOVERABLE;
  }
  const TString fieldTypeName = Utils::getTypeName(*fieldType).c_str();
 
  // Check if we have the needed dictionary for an object field:
  ::TClass* fieldClass = nullptr;
  if (!primitiveField) {
    // Get the property's class:
    fieldClass = ::TClass::GetClass(*fieldType, true, true);
    if (!fieldClass) {
      fieldClass = ::TClass::GetClass(fieldTypeName);
    }
    if (!fieldClass) {
      ::Error("xAOD::RAuxStore::setupInputData",
              XAOD_MESSAGE("No dictionary available for class \"%s\""),
              fieldTypeName.Data());
      return StatusCode::FAILURE;
    }
  }
 
  // Create the smart object holding this vector:
  if (details::isRegisteredType(auxid)) {
    m_data.m_vecs[auxid] = r.makeVector(auxid, (size_t)0, (size_t)0);
    if (!containerField) {
      m_data.m_vecs[auxid]->resize(1);
    }
    if (fieldClass &&
        strncmp(fieldClass->GetName(), "SG::PackedContainer<", 20) == 0) {
      std::unique_ptr<SG::IAuxTypeVector> packed =
          m_data.m_vecs[auxid]->toPacked();
      std::swap(m_data.m_vecs[auxid], packed);
    }
  } else {
    ::Error("xAOD::RAuxStore::setupInputData",
            XAOD_MESSAGE("Couldn't create in-memory vector for "
                         "variable %s (%i)"),
            fieldName.c_str(), static_cast<int>(auxid));
    return StatusCode::FAILURE;
  }
 
  // Access/create the field, and create a field handle object.
  void* objectPtr = (containerField ? m_data.m_vecs[auxid]->toVector()
                                    : m_data.m_vecs[auxid]->toPtr());
  m_impl->m_fields[auxid] = std::make_unique<RFieldHandle>(
      m_impl->m_inTuple->GetView<void>(fieldName.c_str(), objectPtr), auxid,
      m_data.m_prefix, objectPtr, fieldType);
 
  // Get the current entry.
  RETURN_CHECK("xAOD::RAuxStore::setupInputData",
               m_impl->m_fields[auxid]->getEntry(m_impl->m_entry));
 
  // Remember which variable got created:
  m_data.m_auxIDs.insert(auxid);
 
  // Check if we just replaced a generic object:
  if (details::isRegisteredType(auxid)) {
    // The name of the variable we just created:
    const std::string auxname = r.getName(auxid);
    // Check if there's another variable with this name already:
    for (SG::auxid_t i = 0; i < m_data.m_vecs.size(); ++i) {
      // Check if we have this aux ID:
      if (!m_data.m_vecs[i]) {
        continue;
      }
      // Ingore the object that we *just* created:
      if (i == auxid) {
        continue;
      }
      // The name of the variable:
      const std::string testname = r.getName(i);
      // Check if it has the same name:
      if (testname != auxname) {
        continue;
      }
      // Check that the other one is a non-registered type:
      if (details::isRegisteredType(i)) {
        ::Error("xAOD::RAuxStore::setupInputData",
                XAOD_MESSAGE("Internal logic error!"));
        continue;
      }
      // Okay, we do need to remove this object:
      m_data.m_vecs[i].reset();
      m_impl->m_fields[i].reset();
      m_data.m_auxIDs.erase(i);
    }
  }
 
  SG::auxid_t linked_auxid = r.linkedVariable(auxid);
  if (linked_auxid != SG::null_auxid) {
    return setupInputData(linked_auxid);
  }
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

setupOutputData()

StatusCode xAOD::RAuxStore::setupOutputData ( SG::auxid_t auxid )

overrideprivatevirtual

Connect a variable to the output.

This function is used internally to create an output field with the contents of a single auxiliary variable.

Parameters

auxid

The ID of the variable to create an output field for

Returns

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

Implements xAOD::details::AuxStoreBase.

Definition at line 989 of file RAuxStore.cxx.

                                                     {
 
  assert(m_impl);
 
  // Check whether we need to do anything.
  if (!m_impl->m_outTuple) {
    return StatusCode::SUCCESS;
  }
 
  // Check if the variable needs to be written out.
  if (!isAuxIDSelected(auxid)) {
    return StatusCode::SUCCESS;
  }
 
  // Make sure that containers are large enough:
  if (m_data.m_vecs.size() <= auxid) {
    m_data.m_vecs.resize(auxid + 1);
  }
  if (m_impl->m_fieldsWritten.size() <= auxid) {
    m_impl->m_fieldsWritten.resize(auxid + 1);
  }
 
  // Check if this auxiliary variable is already in the output:
  if (m_impl->m_fieldsWritten[auxid]) {
    return StatusCode::SUCCESS;
  }
 
  // After this point, we either succeed with setting up the writing of this
  // variable, or the code fails completely. So let's set this flag already,
  // as unfortunately we can recursively end up here using the code below.
  m_impl->m_fieldsWritten[auxid] = true;
 
  // The registry:
  SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
 
  // Check if the variable was put into the transient store as a
  // decoration, and now needs to be put into the output file:
  if ((!m_data.m_vecs[auxid]) && m_data.m_transientStore &&
      (m_data.m_transientStore->getAuxIDs().test(auxid))) {
 
    // Get the variable from the transient store:
    const void* pptr = m_data.m_transientStore->getData(auxid);
    if (!pptr) {
      ::Fatal("xAOD::RAuxStore::setupOutputData",
              XAOD_MESSAGE("Internal logic error detected"));
      return StatusCode::FAILURE;
    }
 
    // Create the new object:
    m_data.m_vecs[auxid] = reg.makeVector(auxid, m_data.m_size, m_data.m_size);
    void* ptr = m_data.m_vecs[auxid]->toPtr();
    if (!ptr) {
      ::Error("xAOD::RAuxStore::setupOutputData",
              XAOD_MESSAGE("Couldn't create decoration in memory "
                           "for writing"));
      return StatusCode::FAILURE;
    }
 
    // Get the type of this variable:
    const std::type_info* type = reg.getType(auxid);
    if (!type) {
      ::Error("xAOD::RAuxStore::setupOutputData",
              XAOD_MESSAGE("Couldn't get the type of transient "
                           "variable %i"),
              static_cast<int>(auxid));
      return StatusCode::FAILURE;
    }
    // Now get the factory for this variable:
    const SG::IAuxTypeVectorFactory* factory = reg.getFactory(auxid);
    if (!factory) {
      ::Error("xAOD::RAuxStore::setupOutputData",
              XAOD_MESSAGE("No factory found for transient variable "
                           "%i"),
              static_cast<int>(auxid));
      return StatusCode::FAILURE;
    }
 
    // Mark it as a decoration already, otherwise the copy may fail.
    if (m_data.m_isDecoration.size() <= auxid) {
      m_data.m_isDecoration.resize(auxid + 1);
    }
    m_data.m_isDecoration[auxid] = true;
 
    // Finally, do the copy, and remove the variable from the transient store.
    factory->copy(auxid, SG::AuxVectorInterface(*this), 0,
                  SG::AuxVectorInterface(*m_data.m_transientStore), 0,
                  m_data.m_size);
  }
 
  // Check if we know about this variable to be on the input,
  // but haven't connected to it yet:
  if ((m_data.m_auxIDs.test(auxid)) && (!m_data.m_vecs[auxid]) &&
      (!m_impl->m_fields[auxid])) {
    RETURN_CHECK("xAOD::RAuxStore::setupOutputData", setupInputData(auxid));
  }
 
  // Check that we know the store's type:
  if ((m_data.m_structMode != EStructMode::kContainerStore) &&
      (m_data.m_structMode != EStructMode::kObjectStore)) {
    ::Error("xAOD::RAuxStore::setupOutputData",
            XAOD_MESSAGE("Structure mode unknown for variable %s"),
            reg.getName(auxid).c_str());
    return StatusCode::FAILURE;
  }
 
  // Check if the variable exists already in memory:
  if (!m_data.m_vecs[auxid]) {
    m_data.m_vecs[auxid] = reg.makeVector(auxid, (size_t)0, (size_t)0);
    if (m_data.m_structMode == EStructMode::kObjectStore) {
      m_data.m_vecs[auxid]->resize(1);
    }
  }
 
  // Figure out the type and name of the output field.
  const std::string fieldName =
      std::format("{}{}", m_data.m_dynPrefix, reg.getName(auxid));
  const std::string typeName = SG::normalizedTypeinfoName(
      *(m_data.m_structMode == EStructMode::kContainerStore
            ? reg.getVecType(auxid)
            : reg.getType(auxid)));
 
  // Update the output ntuple's model.
  {
    auto field = ROOT::RFieldBase::Create(fieldName, typeName).Unwrap();
    auto updater = m_impl->m_outTuple->CreateModelUpdater();
    updater->BeginUpdate();
    updater->AddField(std::move(field));
    updater->CommitUpdate();
  }
 
  // Remember that we now handle this variable.
  m_data.m_auxIDs.insert(auxid);
 
  // We were successful:
  return StatusCode::SUCCESS;
}

shift() [1/2]

virtual void SG::IAuxStore::shift ( size_t pos, ptrdiff_t offs )

pure virtualinherited

Shift the elements of the container.

Parameters

pos	The starting index for the shift.
offs	The (signed) amount of the shift.

This operation shifts the elements in the vectors for all aux data items, to implement an insertion or deletion. offs may be either positive or negative.

If offs is positive, then the container is growing. The container size should be increased by offs, the element at pos moved to pos + offs, and similarly for following elements. The elements between pos and pos + offs should be default-initialized.

If offs is negative, then the container is shrinking. The element at pos should be moved to pos + offs, and similarly for following elements. The container should then be shrunk by -offs elements (running destructors as appropriate).

Implemented in SG::AuxStoreInternal, xAOD::AuxContainerBase, xAOD::AuxInfoBase, xAOD::ByteStreamAuxContainer_v1, and xAOD::ShallowAuxContainer.

shift() [2/2]

void xAOD::details::AuxStoreBase::shift ( std::size_t pos, std::ptrdiff_t offs )

overridevirtualinherited

Shift the contents of the stored arrays.

Definition at line 437 of file AuxStoreBase.cxx.

                                                         {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // A sanity check:
  if (m_data.m_structMode == EStructMode::kObjectStore) {
    ::Error("xAOD::AuxStoreBase::shift",
            XAOD_MESSAGE("Should not have been called for single-object "
                         "store"));
    return;
  }
 
  // Adjust the size of the container:
  if ((static_cast<std::size_t>(std::abs(offs)) > m_data.m_size) &&
      (offs < 0)) {
    m_data.m_size = 0;
  } else {
    m_data.m_size += offs;
  }
 
  for (auto& v : m_data.m_vecs) {
    if (v && !v->isLinked()) {
      v->shift(pos, offs);
    }
  }
 
  if (m_data.m_transientStore) {
    m_data.m_transientStore->shift(pos, offs);
  }
}

size()

std::size_t xAOD::details::AuxStoreBase::size ( ) const

overridevirtualinherited

Return the number of elements in the store.

Implements SG::IConstAuxStore.

Definition at line 253 of file AuxStoreBase.cxx.

                                   {
 
  // First, try to find a managed vector in the store:
  for (SG::auxid_t id : m_data.m_auxIDs) {
    // Make sure that we are still within the bounds of our vector:
    if (id >= m_data.m_vecs.size())
      break;
    // Skip non-existent or linked objects:
    if (!m_data.m_vecs[id] || m_data.m_vecs[id]->isLinked()) {
      continue;
    }
    // Ask the vector for its size:
    const std::size_t size = m_data.m_vecs[id]->size();
    // Only accept a non-zero size. Not sure why...
    if (size > 0) {
      return size;
    }
  }
 
  // Check if we have a transient store, and get the size from that:
  if (m_data.m_transientStore) {
    return m_data.m_transientStore->size();
  }
 
  // Apparently the store is empty:
  return 0;
}

structMode()

auto xAOD::details::AuxStoreBase::structMode ( ) const

inherited

Get what structure mode the object was constructed with.

Definition at line 29 of file AuxStoreBase.cxx.

                                                   {
 
  return m_data.m_structMode;
}

writeTo()

StatusCode xAOD::RAuxStore::writeTo

(

ROOT::RNTupleWriter &

writer

)

Add the variables of the store to an output RNTuple.

This function is called by the infrastructure to connect the object to an output RNTuple.

Parameters

writer

The writer object used for creating an output ntuple

Returns

kTRUE if successful, kFALSE otherwise

Definition at line 645 of file RAuxStore.cxx.

                                                       {
 
  assert(m_impl);
 
  // Look for any auxiliary fields that have not been connected to yet.
  RETURN_CHECK("xAOD::RAuxStore::writeTo", m_impl->scanInputTuple());
 
  // Put the object into "output writing" mode.
  m_impl->m_outTuple = &writer;
 
  // Create all the variables that we already know about. Notice that the
  // code makes a copy of the auxid set on purpose. Because the underlying
  // AuxSelection object gets modified while doing the for loop.
  const SG::auxid_set_t selAuxIDs = getSelectedAuxIDs();
  for (SG::auxid_t id : selAuxIDs) {
    RETURN_CHECK("xAOD::RAuxStore::writeTo", setupOutputData(id));
  }
 
  // Return gracefully.
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_data

Members xAOD::details::AuxStoreBase::m_data

protectedinherited

Member variables of the base class.

Definition at line 201 of file AuxStoreBase.h.

m_impl

std::unique_ptr<impl> xAOD::RAuxStore::m_impl

private

Pointer to the internal object.

Definition at line 89 of file RAuxStore.h.

m_locked

bool xAOD::details::AuxStoreBase::m_locked = false

privateinherited

Is this container locked?

Definition at line 212 of file AuxStoreBase.h.

m_mutex1

mutex_t xAOD::details::AuxStoreBase::m_mutex1

mutableprivateinherited

Mutex objects used for multithreaded synchronisation.

Definition at line 214 of file AuxStoreBase.h.

m_mutex2

mutex_t xAOD::details::AuxStoreBase::m_mutex2

privateinherited

Definition at line 214 of file AuxStoreBase.h.

m_selection

AuxSelection xAOD::details::AuxStoreBase::m_selection

privateinherited

Object helping to select which auxiliary variables to write.

Definition at line 210 of file AuxStoreBase.h.

supportsThinning

bool SG::IAuxStore::supportsThinning = true

staticconstexprinherited

Mark that this type supports thinning operations.

See AthContainers/supportsThinning.h and AthenaPoolCnvSvc/T_AthenaPoolCnv.h. Helps guide which pool converter template will be used. If false, the default pool converter will be used rather than the aux store-specific one. Ordinary xAOD type should not touch this, but may be overridden in a derived class to handle certain special cases.

Definition at line 199 of file IAuxStore.h.

---

The documentation for this class was generated from the following files:

• RAuxStore.h
• RAuxStore.cxx