xAOD::TAuxStore Class Reference

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

#include <TAuxStore.h>

Inheritance diagram for xAOD::TAuxStore:

Collaboration diagram for xAOD::TAuxStore:

Classes
struct	impl

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

Public Member Functions
	TAuxStore (const EventContext &ctx, std::string_view prefix="", bool topStore=true, EStructMode mode=EStructMode::kUndefinedStore, int basketSize=2048, int splitLevel=0)
	Constructor.
virtual	~TAuxStore ()
	Destructor.
virtual void	setPrefix (std::string_view prefix) override
	Set the object name prefix.
int	basketSize () const
	Get the size of the baskets created for the output branches.
void	setBasketSize (int value)
	Set the size of the baskets created for the output branches.
int	splitLevel () const
	Get the split level of the output branches.
void	setSplitLevel (int value)
	Set the split level of the output branches.
StatusCode	readFrom (::TTree &tree, bool printWarnings=true)
	Connect the object to an input TTree.
StatusCode	writeTo (::TTree &tree)
	Connect the object to an output TTree.
int	getEntry (int getall=0)
	Read the values from the TTree entry that was loaded with TTree::LoadTree().
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 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 SG::auxid_set_t	getCopyIDs (bool warnUnlocked=false) const override
	Get the set of variables that we should deep copy.
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.
virtual void	toTransient (const EventContext &ctx) override
	Call toTransient on contained variables.
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 TTree implementation" of IAuxStore

This is a "D3PDReader-like" implementation for the auxiliary store interface. It is meant to provide very efficient access to a relatively small number of auxiliary variables.

Author

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 31 of file TAuxStore.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 212 of file AuxStoreBase.h.

mutex_t

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

protectedinherited

Mutex type for multithread synchronization.

Definition at line 210 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

TAuxStore()

xAOD::TAuxStore::TAuxStore	(	const EventContext &	ctx,
		std::string_view	prefix = "",
		bool	topStore = true,
		EStructMode	mode = EStructMode::kUndefinedStore,
		int	basketSize = 2048,
		int	splitLevel = 0 )

Constructor.

Definition at line 831 of file TAuxStore.cxx.

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

~TAuxStore()

xAOD::TAuxStore::~TAuxStore ( )

virtualdefault

Destructor.

Member Function Documentation

basketSize()

int xAOD::TAuxStore::basketSize

(

)

const

Get the size of the baskets created for the output branches.

Definition at line 849 of file TAuxStore.cxx.

                                {
 
  assert(m_impl);
  return m_impl->m_basketSize;
}

clearDecorations()

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

overridevirtualinherited

Remove the decorations added so far.

Only works for transient decorations.

Definition at line 222 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;
}

getAuxIDs()

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

overridevirtualinherited

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

Definition at line 106 of file AuxStoreBase.cxx.

                                                   {
 
  return m_data.m_auxIDs;
}

getCopyIDs()

SG::auxid_set_t xAOD::details::AuxStoreBase::getCopyIDs ( bool warnUnlocked = false ) const

overridevirtualinherited

Get the set of variables that we should deep copy.

Definition at line 193 of file AuxStoreBase.cxx.

{
  return SG::getCopyIDs (getAuxIDs(), getDecorIDs(), warnUnlocked, {});
}

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 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.

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 328 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()

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.

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 637 of file AuxStoreBase.cxx.

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

getEntry()

int xAOD::TAuxStore::getEntry

(

int

getall = 0

)

Read the values from the TTree entry that was loaded with TTree::LoadTree().

Definition at line 945 of file TAuxStore.cxx.

                                  {
 
  assert(m_impl);
 
  // Guard against multi-threaded execution:
  guard_t guard(m_impl->m_mutex);
 
  // 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 0;
  }
 
  // Get all the variables at once:
  int bytesRead = 0;
  for (auto& branchHandle : m_impl->m_branches) {
    if (branchHandle) {
      bytesRead += branchHandle->getEntry();
#ifndef XAOD_STANDALONE
      m_data.m_vecs[branchHandle->auxid()]->toTransient( m_impl->m_ctx );
#endif
    }
  }
  return bytesRead;
}

getEntryFor()

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

overrideprivatevirtual

Load a single variable from the input.

Implements xAOD::details::AuxStoreBase.

Definition at line 1012 of file TAuxStore.cxx.

                                                 {
 
  assert(m_impl);
  assert(m_impl->m_branches.size() > auxid);
  assert(m_impl->m_branches[auxid]);
  const ::Int_t readBytes = m_impl->m_branches[auxid]->getEntry();
  if (readBytes < 0) {
    ::Error("xAOD::TAuxStore::getEntryFor",
            XAOD_MESSAGE("Couldn't read in variable %s"),
            SG::AuxTypeRegistry::instance().getName(auxid).c_str());
    return StatusCode::FAILURE;
  }
#ifndef XAOD_STANDALONE
  m_data.m_vecs[auxid]->toTransient( m_impl->m_ctx );
#endif
  return StatusCode::SUCCESS;
}

getInputObject()

const void * xAOD::TAuxStore::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 1546 of file TAuxStore.cxx.

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

getInputType()

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

overrideprivatevirtual

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

Implements xAOD::details::AuxStoreBase.

Definition at line 1554 of file TAuxStore.cxx.

                                                                 {
 
  assert(m_impl);
  assert(m_impl->m_branches.size() > auxid);
  assert(m_impl->m_branches[auxid]);
  return m_impl->m_branches[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 539 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 598 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 652 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.

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 395 of file AuxStoreBase.cxx.

                                                           {
 
  return getAuxIDs();
}

hasEntryFor()

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

overrideprivatevirtual

Check if a given variable is available from the input.

Implements xAOD::details::AuxStoreBase.

Definition at line 1006 of file TAuxStore.cxx.

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

hasOutput()

bool xAOD::TAuxStore::hasOutput ( ) const

overrideprivatevirtual

Check if an output is being written by the object.

Implements xAOD::details::AuxStoreBase.

Definition at line 1030 of file TAuxStore.cxx.

                                {
 
  assert(m_impl);
  return (m_impl->m_outTree != 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.

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 489 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 668 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.

Definition at line 199 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.

Definition at line 287 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 301 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.

Definition at line 211 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.

Definition at line 252 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::TAuxStore::readFrom	(	::TTree &	tree,
		bool	printWarnings = true )

Connect the object to an input TTree.

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

Parameters

tree	Pointer to the TTree that is being read from

Definition at line 878 of file TAuxStore.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_missingBranches.clear();
 
  // Remember the tree:
  m_impl->m_inTree = &tree;
 
  // Catalogue all the branches:
  RETURN_CHECK("xAOD::TAuxStore::readFrom", m_impl->scanInputTree());
 
  // Check if we'll be likely to be able to read the "static"
  // variables:
  assert(m_impl->m_inTree != nullptr);
  TBranch* br = m_impl->m_inTree->GetBranch(m_data.m_prefix.data());
  if (br == nullptr) {
    // We might not even have static branches, so this is not an error
    // by itself...
    return StatusCode::SUCCESS;
  }
  // In order to read complex objects, like smart pointers from an
  // auxiliary container variable-by-variable, the split level of the
  // branch must be exactly 1.
  if ((br->GetSplitLevel() != 1) && m_data.m_topStore && printWarnings) {
    ::Warning("xAOD::TAuxStore::readFrom",
              "Static branch (%s) with split level %i discovered",
              m_data.m_prefix.data(), br->GetSplitLevel());
    ::Warning("xAOD::TAuxStore::readFrom",
              "The reading of complex variables from it may/will fail!");
  }
 
  // 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 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 433 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::TAuxStore::reset ( )

overridevirtual

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

Implements xAOD::details::AuxStoreBase.

Definition at line 994 of file TAuxStore.cxx.

                      {
 
  assert(m_impl);
 
  for (auto& branchHandle : m_impl->m_branches) {
    if (branchHandle) {
      branchHandle->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 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 400 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 645 of file AuxStoreBase.cxx.

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

setBasketSize()

void xAOD::TAuxStore::setBasketSize

(

int

value

)

Set the size of the baskets created for the output branches.

Definition at line 855 of file TAuxStore.cxx.

                                       {
 
  assert(m_impl);
  m_impl->m_basketSize = value;
}

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 xAOD::AuxContainerBase, and xAOD::AuxInfoBase.

Definition at line 189 of file IAuxStore.h.

  { return false; }

setPrefix()

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

overridevirtual

Set the object name prefix.

Implements xAOD::details::AuxStoreBase.

Definition at line 842 of file TAuxStore.cxx.

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

setSplitLevel()

void xAOD::TAuxStore::setSplitLevel

(

int

value

)

Set the split level of the output branches.

Definition at line 867 of file TAuxStore.cxx.

                                       {
 
  assert(m_impl);
  m_impl->m_splitLevel = value;
}

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::TAuxStore::setupInputData ( SG::auxid_t auxid )

overrideprivatevirtual

Connect a variable to the input.

Connect a variable to the input tree.

This internal function takes care of connecting to an individual (sub-)branch in the input file for a given auxiliary variable. It needs to handle a number of different use cases, so it's a bit long.

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 1046 of file TAuxStore.cxx.

                                                    {
 
  assert(m_impl);
 
  // Return right away if we already know that the branch is missing.
  if ((auxid < m_impl->m_missingBranches.size()) &&
      m_impl->m_missingBranches[auxid]) {
    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_branches.size() <= auxid) {
    m_impl->m_branches.resize(auxid + 1);
  }
 
  // Check if we need to do anything:
  if (m_data.m_vecs[auxid] && m_impl->m_branches[auxid]) {
    return StatusCode::SUCCESS;
  }
 
  // A little sanity check.
  if (m_impl->m_inTree == nullptr) {
    ::Error("xAOD::TAuxStore::setupInputData",
            XAOD_MESSAGE("No input TTree set up!"));
    return StatusCode::FAILURE;
  }
 
  // Another sanity check.
  if (m_data.m_vecs[auxid] || m_impl->m_branches[auxid]) {
    ::Error("xAOD::TAuxStore::setupInputData",
            XAOD_MESSAGE("Internal logic error!"));
    return StatusCode::FAILURE;
  }
 
  // Convenience access to the registry.
  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  // Get the property name:
  const TString statBrName =
      std::format("{}{}", m_data.m_prefix, r.getName(auxid));
  const TString dynBrName =
      std::format("{}{}", m_data.m_dynPrefix, r.getName(auxid));
 
  // Check if the branch exists:
  Bool_t staticBranch = true;
  TString brName = statBrName;
 
  TBranch* br = m_impl->m_inTree->GetBranch(statBrName);
  if (!br) {
    br = m_impl->m_inTree->GetBranch(dynBrName);
    if (!br) {
      // Since TTree::GetBranch / TTObjArray::FindObject is expensive,
      // remember that we didn't find this branch in this file.
      if (m_impl->m_missingBranches.size() <= auxid) {
        m_impl->m_missingBranches.resize(auxid + 1);
      }
      m_impl->m_missingBranches[auxid] = true;
      // The branch 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 branch:
    staticBranch = false;
    brName = dynBrName;
  }
 
  // Check if it's a "primitive branch":
  const Bool_t primitiveBranch = isPrimitiveBranch(*br);
  // Check if it's a "container branch":
  const Bool_t containerBranch =
      (primitiveBranch ? false : isContainerBranch(*br, auxid));
 
  // Set the structure mode if it has not been defined externally:
  if (m_data.m_structMode == EStructMode::kUndefinedStore) {
    m_data.m_structMode = (containerBranch ? EStructMode::kContainerStore
                                           : EStructMode::kObjectStore);
  }
 
  // Check that the branch type makes sense:
  if ((containerBranch &&
       (m_data.m_structMode != EStructMode::kContainerStore) &&
       !r.isLinked(auxid)) ||
      ((!containerBranch) &&
       (m_data.m_structMode != EStructMode::kObjectStore))) {
    ::Error("xAOD::TAuxStore::setupInputData",
            XAOD_MESSAGE("Branch type and requested structure mode "
                         "differ for branch: %s"),
            brName.Data());
    return StatusCode::FAILURE;
  }
 
  // Check what variable it is:
  ::TClass* clDummy = 0;
  ::EDataType dType = kOther_t;
  if (br->GetExpectedType(clDummy, dType)) {
    ::Error("xAOD::TAuxStore::setupInputData",
            XAOD_MESSAGE("Couldn't determine the type of branch \"%s\""),
            brName.Data());
    return StatusCode::FAILURE;
  }
 
  // Get the property type:
  const std::type_info* brType = 0;
  if (details::isRegisteredType(auxid)) {
    // Get the type from the auxiliary type registry:
    brType = (containerBranch ? r.getVecType(auxid) : r.getType(auxid));
  } else {
    // Get the type from the input branch itself:
    brType = (clDummy ? clDummy->GetTypeInfo() : &(Utils::getTypeInfo(dType)));
  }
  if (!brType) {
    ::Error("xAOD::TAuxStore::setupInputData",
            XAOD_MESSAGE("Can't read/copy variable %s (%s)"), brName.Data(),
            clDummy->GetName());
    return StatusCode::RECOVERABLE;
  }
  const TString brTypeName = Utils::getTypeName(*brType).c_str();
 
  // Check if we have the needed dictionary for an object branch:
  ::TClass* brClass = 0;
  if (!primitiveBranch) {
    // Get the property's class:
    brClass = ::TClass::GetClass(*brType, true, true);
    if (!brClass) {
      brClass = ::TClass::GetClass(brTypeName);
    }
    if (!brClass) {
      ::Error("xAOD::TAuxStore::setupInputData",
              XAOD_MESSAGE("No dictionary available for class \"%s\""),
              brTypeName.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 (!containerBranch) {
      m_data.m_vecs[auxid]->resize(1);
    }
    if (clDummy &&
        strncmp(clDummy->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::TAuxStore::setupInputData",
            XAOD_MESSAGE("Couldn't create in-memory vector for "
                         "variable %s (%i)"),
            brName.Data(), static_cast<int>(auxid));
    return StatusCode::FAILURE;
  }
 
  // Create a new branch handle:
  const std::type_info* objType = brType;
  if (containerBranch) {
    objType = m_data.m_vecs[auxid]->objType();
    if (!objType)
      objType = r.getType(auxid);
  }
  m_impl->m_branches[auxid] = std::make_unique<TBranchHandle>(
      staticBranch, primitiveBranch, objType,
      (containerBranch ? m_data.m_vecs[auxid]->toVector()
                       : m_data.m_vecs[auxid]->toPtr()),
      auxid, m_data.m_prefix);
 
  // Set the tree/branch in the "right mode":
  if (staticBranch) {
    br->SetMakeClass();
  }
 
  // Connect to the branch:
  ::Int_t status = 0;
  if (clDummy && ::TString(clDummy->GetName()).Contains("basic_string<char>")) {
    // This is pretty much just a hack. As it happens, Athena I/O can
    // create dynamic branches that consider themselves to be of type
    // "vector<basic_string<char> >" and similar. (Instead of the
    // canonical "vector<string>" name.) When we encounter such a branch,
    // we just connect to it without performing any compatibility checks.
    // Since we don't need to apply any read rules in this case anyway.
    status = m_impl->m_inTree->SetBranchAddress(
        brName, m_impl->m_branches[auxid]->inputObjectPtr(),
        m_impl->m_branches[auxid]->branchPtr());
  } else {
    status = m_impl->m_inTree->SetBranchAddress(
        brName, m_impl->m_branches[auxid]->inputObjectPtr(),
        m_impl->m_branches[auxid]->branchPtr(), brClass, dType,
        ((!staticBranch) && (!primitiveBranch)));
  }
  if (status < 0) {
    ::Error("xAOD::TAuxStore::setupInputData",
            XAOD_MESSAGE("Coulnd't connect to branch \"%s\""), brName.Data());
    ::Error("xAOD::TAuxStore::setupInputData", XAOD_MESSAGE("Return code: %i"),
            status);
    m_data.m_vecs[auxid].reset();
    m_impl->m_branches[auxid].reset();
    return StatusCode::FAILURE;
  }
 
  // Get the current entry:
  m_impl->m_branches[auxid]->getEntry();
#ifndef XAOD_STANDALONE
  m_data.m_vecs[auxid]->toTransient( m_impl->m_ctx );
#endif
 
  // 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::TAuxStore::setupInputData",
                XAOD_MESSAGE("Internal logic error!"));
        continue;
      }
      // Okay, we do need to remove this object:
      m_data.m_vecs[i].reset();
      m_impl->m_branches[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::TAuxStore::setupOutputData ( SG::auxid_t auxid )

overrideprivatevirtual

Connect a variable to the output.

Connect a variable to the output tree.

This function is used internally to create a "simple" output branch with the contents of a single auxiliary variable.

Parameters

auxid

The ID of the variable to create an output branch for

Returns

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

Implements xAOD::details::AuxStoreBase.

Definition at line 1309 of file TAuxStore.cxx.

                                                     {
 
  assert(m_impl);
 
  // Check whether we need to do anything:
  if (!m_impl->m_outTree) {
    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_branches.size() <= auxid) {
    m_impl->m_branches.resize(auxid + 1);
  }
  if (m_impl->m_branchesWritten.size() <= auxid) {
    m_impl->m_branchesWritten.resize(auxid + 1);
  }
 
  // Check if this auxiliary variable is already in the output:
  if (m_impl->m_branchesWritten[auxid]) {
    return StatusCode::SUCCESS;
  }
 
  // 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::TAuxStore::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::TAuxStore::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::TAuxStore::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::TAuxStore::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:
    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_branches[auxid])) {
    RETURN_CHECK("xAOD::TAuxStore::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::TAuxStore::setupOutputData",
            XAOD_MESSAGE("Structure mode unknown for variable %s"),
            SG::AuxTypeRegistry::instance().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] =
        SG::AuxTypeRegistry::instance().makeVector(auxid, (size_t)0, (size_t)0);
    if (m_data.m_structMode == EStructMode::kObjectStore) {
      m_data.m_vecs[auxid]->resize(1);
    }
  }
 
  // Check if the branch handle exists already:
  if (!m_impl->m_branches[auxid]) {
    // Get the property type:
    const std::type_info* brType =
        (m_data.m_structMode == EStructMode::kContainerStore
             ? SG::AuxTypeRegistry::instance().getVecType(auxid)
             : SG::AuxTypeRegistry::instance().getType(auxid));
    // Create the handle object:
    bool primitiveBranch = (strlen(brType->name()) == 1);
    m_impl->m_branches[auxid] = std::make_unique<TBranchHandle>(
        false, (strlen(brType->name()) == 1),
        (primitiveBranch ? brType : m_data.m_vecs[auxid]->objType()),
        (m_data.m_structMode == EStructMode::kObjectStore
             ? m_data.m_vecs[auxid]->toPtr()
             : m_data.m_vecs[auxid]->toVector()),
        auxid, m_data.m_prefix);
  }
 
  // Construct a name for the branch:
  const TString brName =
      std::format("{}{}", m_data.m_dynPrefix,
                  SG::AuxTypeRegistry::instance().getName(auxid));
 
  // If the output branch exists already, assume that it was us making
  // it:
  ::TBranch* br = m_impl->m_outTree->GetBranch(brName);
  if (br) {
    // Apparently a branch that was already set up for copying as a basic
    // variable, now got accessed explicitly. So let's update the output
    // branch to point to this new location now.
    br->SetAddress(m_impl->m_branches[auxid]->outputObjectPtr());
    // Update the cache. Notice that the "write status" of the typeless
    // auxiliary ID is not turned off. But it shouldn't matter, as the
    // variable will not be accessed in a typeless way anymore.
    m_impl->m_branchesWritten[auxid] = true;
    // Return gracefully:
    return StatusCode::SUCCESS;
  }
 
  // Check that we know the type of the branch:
  const std::type_info* brType = m_impl->m_branches[auxid]->typeInfo();
  if (!brType) {
    ::Error("xAOD::TAuxStore::setupOutputData",
            XAOD_MESSAGE("There's an internal logic error in the "
                         "code"));
    return StatusCode::FAILURE;
  }
  const std::string brTypeName = Utils::getTypeName(*brType);
 
  // Decide if this is a primitive branch:
  const Bool_t primitiveBranch = (strlen(brType->name()) == 1);
 
  // Let's create the branch now:
  if (primitiveBranch) {
 
    // Get the "ROOT type" belonging to this primitive:
    const char rootType = Utils::rootType(brType->name()[0]);
    if (rootType == '\0') {
      ::Error("xAOD::TAuxStore::setupOutputData",
              XAOD_MESSAGE("Type not known for variable \"%s\" "
                           "of type \"%s\""),
              brName.Data(), brTypeName.c_str());
      return StatusCode::FAILURE;
    }
 
    // Construct the type description:
    std::ostringstream typeDesc;
    typeDesc << brName << "/" << rootType;
 
    // Create the branch:
    br = m_impl->m_outTree->Branch(
        brName, m_impl->m_branches[auxid]->outputObjectPtr(),
        typeDesc.str().c_str(), m_impl->m_basketSize);
 
  } else {
 
    // Access the dictionary for the type:
    TClass* cl = TClass::GetClass(*brType);
    if (!cl) {
      cl = TClass::GetClass(brTypeName.c_str());
    }
    if (!cl) {
      ::Error("xAOD::TAuxStore::setupOutputData",
              XAOD_MESSAGE("Couldn't find dictionary for type: %s"),
              brTypeName.c_str());
      return StatusCode::FAILURE;
    }
    if (!cl->GetStreamerInfo()) {
      ::Error("xAOD::TAuxStore::setupOutputData",
              XAOD_MESSAGE("No streamer info available for type %s"),
              cl->GetName());
      return StatusCode::FAILURE;
    }
 
    // Create the branch:
    br = m_impl->m_outTree->Branch(brName, cl->GetName(),
                                   m_impl->m_branches[auxid]->outputObjectPtr(),
                                   m_impl->m_basketSize, m_impl->m_splitLevel);
  }
 
  // Check if we succeeded:
  if (!br) {
    ::Error("xAOD::TAuxStore::setupOutputData",
            XAOD_MESSAGE("Failed creating branch \"%s\" of type "
                         "\"%s\""),
            brName.Data(), brTypeName.c_str());
    return StatusCode::FAILURE;
  }
 
  // If this is not the first event, fill up the branch with dummy
  // info:
  for (Long64_t i = 0; i < m_impl->m_outTree->GetEntries(); ++i) {
    br->Fill();
  }
 
  // Update the cache:
  m_impl->m_branchesWritten[auxid] = true;
 
  // Also, 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 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 457 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.

Definition at line 259 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;
}

splitLevel()

int xAOD::TAuxStore::splitLevel

(

)

const

Get the split level of the output branches.

Definition at line 861 of file TAuxStore.cxx.

                                {
 
  assert(m_impl);
  return m_impl->m_splitLevel;
}

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;
}

toTransient()

void xAOD::details::AuxStoreBase::toTransient ( const EventContext & ctx )

overridevirtualinherited

Call toTransient on contained variables.

Implements SG::IAuxStore.

Definition at line 314 of file AuxStoreBase.cxx.

                                                        {
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  for (auto& v : m_data.m_vecs) {
    if (v) {
      v->toTransient( ctx );
    }
  }
  if (m_data.m_transientStore) {
    m_data.m_transientStore->toTransient(ctx);
  }
}

writeTo()

StatusCode xAOD::TAuxStore::writeTo

(

::TTree &

tree

)

Connect the object to an output TTree.

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

Parameters

tree	Pointer to the TTree that is being written to

Definition at line 923 of file TAuxStore.cxx.

                                         {
 
  assert(m_impl);
 
  // Look for any auxiliary branches that have not been connected to yet:
  RETURN_CHECK("xAOD::TAuxStore::writeTo", m_impl->scanInputTree());
 
  // Store the TTree pointer:
  m_impl->m_outTree = &tree;
 
  // 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::TAuxStore::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 207 of file AuxStoreBase.h.

m_impl

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

private

Pointer to the internal object.

Definition at line 93 of file TAuxStore.h.

m_locked

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

privateinherited

Is this container locked?

Definition at line 218 of file AuxStoreBase.h.

m_mutex1

mutex_t xAOD::details::AuxStoreBase::m_mutex1

mutableprivateinherited

Mutex objects used for multithreaded synchronisation.

Definition at line 220 of file AuxStoreBase.h.

m_mutex2

mutex_t xAOD::details::AuxStoreBase::m_mutex2

privateinherited

Definition at line 220 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 216 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 216 of file IAuxStore.h.

---

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

• TAuxStore.h
• TAuxStore.cxx