xAOD::RAuxStore Class Reference

#include <RAuxStore.h>

Inheritance diagram for xAOD::RAuxStore:

Collaboration diagram for xAOD::RAuxStore:

Classes
class	RFieldInfo

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

Public Member Functions
	RAuxStore (const char *prefix="", Bool_t topStore=kTRUE, EStructMode mode=kUndefinedStore)
virtual	~RAuxStore ()
	Destructor. More...
EStructMode	structMode () const
	Return the structure mode of the object. More...
StatusCode	readFrom (const std::string &fileName, const std::string &ntupleName)
	Connect the object to an input RNTuple. More...
StatusCode	writeTo (const std::string &fileName, const std::string &ntupleName)
	Connect the object to an output RNTuple. More...
::Int_t	getEntry (Long64_t entry, ::Int_t getall=0)
	Get entry from the input RNTuple. More...
void	reset ()
	Reset the store. More...
virtual const void *	getData (SG::auxid_t auxid) const=0
	Pick up the const version from the base class. More...
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. More...
virtual bool	setOption (auxid_t, const AuxDataOption &)
	Set an option for a given auxiliary variable. More...
virtual const IAuxTypeVector *	linkedVector (SG::auxid_t) const
	Return interface for a linked variable. More...
Functions implementing the SG::IConstAuxStore interface
Get a pointer to a given array
virtual const void *	getData (auxid_t auxid) const override
	Get a pointer to a given array. More...
virtual const SG::IAuxTypeVector *	getVector (SG::auxid_t auxid) const override
	Return vector interface for one aux data item. More...
virtual const auxid_set_t &	getAuxIDs () const override
	Get the types(names) of variables handled by this container. More...
virtual const auxid_set_t &	getDecorIDs () const override
	Get the types(names) of decorations handled by this container. More...
virtual void *	getDecoration (auxid_t auxid, size_t size, size_t capacity) override
	Get a pointer to a given array, creating the array if necessary. More...
virtual bool	isDecoration (auxid_t auxid) const override
	Test if a variable is a decoration. More...
virtual void	lock () override
	Lock the object, and don't let decorations be added. More...
virtual bool	clearDecorations () override
	Remove the decorations added so far. More...
virtual void	lockDecoration (SG::auxid_t auxid) override
	Lock a decoration. More...
virtual size_t	size () const override
	Return the number of elements in the store. More...
virtual SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) override
	Return interface for a linked variable. More...
virtual const SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) const override
	Return const interface for a linked variable. More...
Functions implementing the SG::IAuxStore interface
virtual void *	getData (auxid_t auxid, size_t size, size_t capacity) override
	Get a pointer to a given array, creating the array if necessary. More...
virtual const auxid_set_t &	getWritableAuxIDs () const override
	Return a set of writable data identifiers. More...
virtual bool	resize (size_t size) override
	Resize the arrays to a given size. More...
virtual void	reserve (size_t size) override
	Reserve a given size for the arrays. More...
virtual void	shift (size_t pos, ptrdiff_t offs) override
	Shift the contents of the stored arrays. More...
virtual bool	insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore) override
	Insert contents of another store via move. More...
Functions implementing the SG::IAuxStoreIO interface
virtual const void *	getIOData (auxid_t auxid) const override
	Get a pointer to the data being stored for one aux data item. More...
virtual const std::type_info *	getIOType (auxid_t auxid) const override
	Return the type of the data to be stored for one aux data item. More...
virtual const auxid_set_t &	getDynamicAuxIDs () const override
	Get the types(names) of variables created dynamically. More...
virtual void	selectAux (const std::set< std::string > &attributes)
	Select dynamic auxiliary attributes for writing. More...
virtual auxid_set_t	getSelectedAuxIDs () const override
	Get the IDs of the selected aux variables. More...

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

Private Types
typedef SG::auxid_t	auxid_t
	Convenience type declaration. More...
typedef SG::auxid_set_t	auxid_set_t
	Convenience type declaration. More...
typedef AthContainers_detail::mutex	mutex_t
	Mutex type for multithread synchronization. More...
typedef AthContainers_detail::lock_guard< mutex_t >	guard_t
	Guard type for multithreaded synchronisation. More...

Private Member Functions
StatusCode	setupInputData (auxid_t auxid)
	Connect a variable to the input tree. More...
StatusCode	setupOutputData (auxid_t auxid)
	Connect a variable to the output ntuple. More...
StatusCode	scanInputNtuple ()
	Scan the input RNTuple for auxiliary fields. More...
const std::type_info *	auxFieldType (const std::string &fieldName, const std::string &auxName, ::Bool_t staticField)
	Find the type_info to use as the aux type for a given field. More...
StatusCode	setupAuxField (const std::string &fieldName, const std::string &auxName, ::Bool_t staticField)
	Register one input field as an available auxiliary variable. More...
::Bool_t	isAuxIDSelected (auxid_t auxid) const
	Check if this auxiliary variable needs to go to the output. More...
::Bool_t	isPrimitiveField (std::string fieldName)
	Check if a field holds a primitive variable or not. More...
::Bool_t	isContainerField (std::string fieldName, auxid_t auxid) const
	Check if a field describes a container or a single object. More...
StatusCode	addVectorField (std::string fieldName, std::string fieldTypeName, ::Bool_t isInputFile)
	Add a vector field to a model (either the input or the output one) More...
::Bool_t	fieldInfosHasAuxid (auxid_t auxid) const
	Checks if the fieldInfos map has an entry for the given auxid. More...

Static Private Member Functions
::Bool_t	isRegisteredType (auxid_t auxid)
	Check if the auxiliary variable has a registered type. More...

Private Attributes
std::string	m_prefix
	Static prefix for the field names. More...
std::string	m_dynPrefix
	Dynamic prefix for the field names. More...
::Bool_t	m_topStore
	Flag stating whether this is a "top store". More...
EStructMode	m_structMode
	The "structural" mode of the object. More...
std::unique_ptr< RNTupleReader >	m_inNtuple
	The ntuple being read from. More...
std::unique_ptr< RNTupleReader >	m_outNtuple
	The the ntuple being written to. More...
::Bool_t	m_inputScanned
	"Scan status" of the input RNTuple More...
AuxSelection	m_selection
	Object helping to select which auxiliary variables to write. More...
SG::AuxStoreInternal *	m_transientStore {}
	Store for the in-memory-only variables. More...
auxid_set_t	m_auxIDs
	Internal list of variable IDs handled currently by the object. More...
auxid_set_t	m_decorIDs
std::vector< SG::IAuxTypeVector * >	m_vecs
	Variables handled currently by the object. More...
std::size_t	m_size {}
	The current size of the container being described. More...
::Bool_t	m_locked
	Is this container locked? More...
std::vector< ::Bool_t >	m_isDecoration
	Flags items as decorations. More...
mutex_t	m_mutex1
	Mutexes object used for multithreaded synchronisation. More...
mutex_t	m_mutex2
std::string	m_inFileName
	The input file that we are reading from. More...
std::string	m_outFileName
	The output file that we are writing to. More...
std::string	m_inputNtupleName
	The name of the ntuple that we are reading from. More...
std::string	m_outputNtupleName
	The name of the ntuple that we are writing to. More...
std::unique_ptr< RNTupleModel >	m_outModel
	The model of the output ntuple. More...
std::unique_ptr< RNTupleModel >	m_inModel
	The model of the input ntuple. More...
::Long64_t	m_entryToLoad
	The entry to load from the ntuple. More...
std::map< auxid_t, RFieldInfo >	m_fields
	A way to acces an representation of a field with an auxid. More...

Detailed Description

Definition at line 36 of file RAuxStore.h.

Member Typedef Documentation

auxid_set_t

typedef SG::auxid_set_t xAOD::RAuxStore::auxid_set_t

private

Convenience type declaration.

Definition at line 41 of file RAuxStore.h.

auxid_t

typedef SG::auxid_t xAOD::RAuxStore::auxid_t

private

Convenience type declaration.

Definition at line 39 of file RAuxStore.h.

guard_t

typedef AthContainers_detail::lock_guard< mutex_t > xAOD::RAuxStore::guard_t

private

Guard type for multithreaded synchronisation.

Definition at line 220 of file RAuxStore.h.

mutex_t

typedef AthContainers_detail::mutex xAOD::RAuxStore::mutex_t

private

Mutex type for multithread synchronization.

Definition at line 218 of file RAuxStore.h.

Member Enumeration Documentation

EStructMode

enum xAOD::RAuxStore::EStructMode

"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 45 of file RAuxStore.h.

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

Constructor & Destructor Documentation

RAuxStore()

xAOD::RAuxStore::RAuxStore	(	const char *	prefix = "",
		Bool_t	topStore = kTRUE,
		EStructMode	mode = kUndefinedStore
	)

Definition at line 50 of file RAuxStore.cxx.

       : SG::IAuxStore(),
         m_prefix( prefix ),
         m_dynPrefix( Utils::dynFieldPrefix( prefix ) ),
         m_topStore( topStore ),
         m_structMode( mode ),
         m_inNtuple( nullptr ),
         m_outNtuple( nullptr ),
         m_inputScanned( kFALSE ),
         m_selection(),
         m_transientStore( 0 ),
         m_auxIDs(),
         m_decorIDs(),
         m_vecs(),
         m_size( 0 ),
         m_locked( kFALSE ),
         m_isDecoration(),
         m_mutex1(),
         m_mutex2(),
         m_inFileName(),
         m_outFileName(),
         m_inputNtupleName(),
         m_outputNtupleName(),
         m_outModel( nullptr ),
         m_inModel( nullptr ),
         m_entryToLoad( 0 ),
         m_fields() {}

~RAuxStore()

xAOD::RAuxStore::~RAuxStore ( )

virtual

Destructor.

Definition at line 78 of file RAuxStore.cxx.

                        {
    delete m_transientStore;
    m_transientStore = nullptr;
    for( auto& fieldPair : m_fields ) {
      fieldPair.second.field.release();//not a leak (coverity 17624)
    }
    m_fields.clear();  // Ensure m_fields is properly cleared
  }

Member Function Documentation

addVectorField()

StatusCode xAOD::RAuxStore::addVectorField ( std::string  fieldName, std::string  fieldTypeName, ::Bool_t  isInputFile  )

private

Add a vector field to a model (either the input or the output one)

This function creates a base field using the provided field name and type name.

Depending on whether the field is for the input file or the output file, it adds the field to the appropriate ntuple model.

Parameters

fieldName	The name of the field to be added.
fieldTypeName	The type name of the field to be added.
isInputFile	A boolean flag indicating whether the field is for the input file.

Returns

StatusCode::SUCCESS if the field is added successfully, StatusCode::FAILURE otherwise.

Definition at line 1807 of file RAuxStore.cxx.

                                                              {
      auto baseFieldResult = RFieldBase::Create( fieldName, fieldTypeName );
      if( baseFieldResult ) {
         auto baseField = baseFieldResult.Unwrap();
         if( isInputFile ) {
            if( m_inModel != nullptr ) {
               m_inModel->AddField( std::move( baseField ) );
            } else {
               return StatusCode::FAILURE;
            }
         } else {
            if( m_outModel != nullptr ) {
               m_outModel->AddField( std::move( baseField ) );
            } else {
               return StatusCode::FAILURE;
            }
         }
      }
      return StatusCode::SUCCESS;
   }

auxFieldType()

const std::type_info * xAOD::RAuxStore::auxFieldType ( const std::string &  fieldName, const std::string &  auxName, ::Bool_t  isStaticField  )

private

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

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

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

Parameters

fieldName	The name of the field in the ntuple
auxName	The name of the auxiliary field.
isStaticField	kTRUE if this is a static field, and kFALSE if it's a dynamic one

Definition at line 1385 of file RAuxStore.cxx.

                                                                          {
 
      auto inspector =
          RNTupleInspector::Create( m_inputNtupleName, m_inFileName );
      const auto& fieldInspector = inspector->GetFieldTreeInspector( fieldName );
 
      std::string typeName =
          fieldInspector.GetDescriptor().GetTypeName().c_str();
      const auto expectedClass = ::TClass::GetClass(
          fieldInspector.GetDescriptor().GetTypeName().c_str() );
 
      if( ( !expectedClass ) && ( m_structMode == kUndefinedStore ) ) {
         m_structMode = kObjectStore;
      }
 
      const std::type_info* ti = 0;
      if( m_structMode == kObjectStore ) {
         if( expectedClass ) {
            ti = expectedClass->GetTypeInfo();
         } else {
            ti = &( Utils::getTypeInfo( kOther_t ) );
         }
      } else {
         if( !expectedClass ) {
            if( ( !isStaticField ) ||
                ( strncmp( auxName.c_str(), "m_", 2 ) != 0 ) ) {
               ::Warning( "xAOD::RAuxStore::auxFieldType",
                          "Couldn't get the type of field \"%s\"",
                          fieldName.c_str() );
            }
         } else {
            ::TVirtualCollectionProxy* prox =
                expectedClass->GetCollectionProxy();
 
            if( !prox ) {
               TClass* cl2 = lookupVectorType( expectedClass );
               if( cl2 ) prox = cl2->GetCollectionProxy();
            }
 
            if( !prox ) {
               if( ( !isStaticField ) ||
                   ( strncmp( auxName.c_str(), "m_", 2 ) != 0 ) ) {
                  ::Warning( "xAOD::RAuxStore::auxFieldType",
                             "Couldn't get the type of field \"%s\"",
                             fieldName.c_str() );
               }
            } else {
               if( prox->GetValueClass() ) {
                  ti = prox->GetValueClass()->GetTypeInfo();
               } else {
                  ti = &( Utils::getTypeInfo( prox->GetType() ) );
               }
            }
         }
      }
      return ti;
   }

clearDecorations()

bool xAOD::RAuxStore::clearDecorations ( )

overridevirtual

Remove the decorations added so far.

Only works for transient decorations.

Only works for transient decorations.

Returns

True if any decorations were removed; otherwise, false

Implements SG::IConstAuxStore.

Definition at line 406 of file RAuxStore.cxx.

                                    {
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // Clear the transient decorations:
      bool anycleared = false;
      if( m_transientStore ) {
         SG::auxid_set_t oldIdSet = m_transientStore->getAuxIDs();
 
         // Clear the decorations from the transient store:
         anycleared = m_transientStore->clearDecorations();
 
         // Remove ids that were cleared.
         if( anycleared ) {
            oldIdSet -= m_transientStore->getAuxIDs();
            // oldIdSet is now the set of ids that were cleared.
            m_auxIDs -= oldIdSet;
            m_decorIDs.clear();
         }
      }
 
      return anycleared;
   }

fieldInfosHasAuxid()

Bool_t xAOD::RAuxStore::fieldInfosHasAuxid ( auxid_t  auxid ) const

private

Checks if the fieldInfos map has an entry for the given auxid.

Parameters

auxid

The auxid to check for in the fieldInfos map.

Returns

kTRUE if the fieldInfos map has an entry for the given auxid, kFALSE otherwise.

Definition at line 1836 of file RAuxStore.cxx.

                                                             {
      return !( m_fields.find( auxid ) == m_fields.end() );
   }

getAuxIDs()

const RAuxStore::auxid_set_t & xAOD::RAuxStore::getAuxIDs ( ) const

overridevirtual

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

Returns

A constant reference to the set of auxiliary IDs

Implements SG::IConstAuxStore.

Definition at line 276 of file RAuxStore.cxx.

                                                          {
      return m_auxIDs;
   }

getData() [1/3]

const void * xAOD::RAuxStore::getData ( auxid_t  auxid ) const

overridevirtual

Get a pointer to a given array.

Parameters

auxid

The auxiliary ID for which to retrieve the data pointer

Returns

Pointer to the data if it exists; otherwise, nullptr

Implements SG::IConstAuxStore.

Definition at line 218 of file RAuxStore.cxx.

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

getData() [2/3]

void * xAOD::RAuxStore::getData ( auxid_t  auxid, size_t  size, size_t  capacity  )

overridevirtual

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

Retrieves or creates data for a given auxiliary ID.

It handles both transient and output data, ensuring that the data is properly set up and sized.

Parameters

auxid	The auxiliary ID for which data is requested
size	The size of the data to be retrieved or created
capacity	The capacity of the data to be retrieved or created

Returns

A pointer to the data for the given auxiliary ID

Implements SG::IAuxStore.

Definition at line 524 of file RAuxStore.cxx.

                                                                         {
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex2 );
 
      // Remember the size:
      m_size = size;
 
      // Check if we want to write this variable to the output:
      if( ( !m_outNtuple ) || ( !isAuxIDSelected( auxid ) ) ) {
         // Create the store only when necessary:
         if( !m_transientStore ) {
            m_transientStore =
                new SG::AuxStoreInternal( m_structMode == kObjectStore );
            if( m_locked ) {
               m_transientStore->lock();
            }
         }
         // Let the transient store create the variable:
         size_t nids = m_transientStore->getAuxIDs().size();
         void* result = m_transientStore->getData( auxid, size, capacity );
         if( result && ( nids != m_transientStore->getAuxIDs().size() ) ) {
            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_vecs.size() ) && m_vecs[auxid] ) {
         if( !( ( auxid < m_isDecoration.size() ) && m_isDecoration[auxid] ) ) {
            throw SG::ExcStoreLocked( auxid );
         }
      }
 
      // Connect this auxiliary variable just to the output:
      if( setupOutputData( auxid ).isFailure() ) {
         ::Error( "xAOD::RAuxStore::getData",
                  XAOD_MESSAGE( "Failed to set up variable %s" ),
                  SG::AuxTypeRegistry::instance().getName( auxid ).c_str() );
         return 0;
      }
 
      // Check whether things make sense:
      if( ( m_structMode == kObjectStore ) && ( size != 1 ) ) {
         ::Error( "xAOD::RAuxStore::getData",
                  XAOD_MESSAGE( "Field creation requested with:" ) );
         ::Error( "xAOD::RAuxStore::getData", XAOD_MESSAGE( "  name = %s" ),
                  SG::AuxTypeRegistry::instance().getName( auxid ).c_str() );
         ::Error( "xAOD::RAuxStore::getData", XAOD_MESSAGE( "  size = %i" ),
                  static_cast< int >( size ) );
         ::Error( "xAOD::RAuxStore::getData",
                  XAOD_MESSAGE( "  m_structMode = kObjectStore" ) );
         return 0;
      }
 
      // Make sure the variable is of the right size:
      m_vecs[auxid]->reserve( capacity );
      m_vecs[auxid]->resize( size );
 
      // Return the object:
      return m_vecs[auxid]->toPtr();
   }

getData() [3/3]

virtual const void* SG::IConstAuxStore::getData

inherited

Pick up the const version from the base class.

getDecoration()

void * xAOD::RAuxStore::getDecoration ( auxid_t  auxid, size_t  size, size_t  capacity  )

overridevirtual

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

Returns a pointer to the decoration data corresponding to the specified auxid.

If the decoration does not exist, it creates it. Handles locked stores and transient stores appropriately.

Parameters

auxid	The auxiliary ID for which to retrieve or create the decoration.
size	The size of the decoration vector.
capacity	The capacity of the decoration vector.

Returns

Pointer to the decoration data if successful; otherwise, nullptr.

Implements SG::IConstAuxStore.

Definition at line 296 of file RAuxStore.cxx.

                                                     {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // Remember the requested size:
      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_vecs.size() ) && m_vecs[auxid] &&
             ( auxid < m_isDecoration.size() && m_isDecoration[auxid] ) ) {
            // Things look okay...
            m_vecs[auxid]->reserve( capacity );
            m_vecs[auxid]->resize( size );
            return 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_transientStore && m_transientStore->getAuxIDs().test( auxid ) ) {
            return 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_auxIDs.test( auxid ) ) {
            // It may still be a decoration in a transient store. If such
            // a store exists, leave it up to that store to
            throw SG::ExcStoreLocked( auxid );
         }
      }
 
      // Check if we want to write this variable to the output:
      if( ( !isAuxIDSelected( auxid ) ) || ( !m_outNtuple ) ) {
 
         // Create the store only when necessary:
         if( !m_transientStore ) {
            m_transientStore =
                new SG::AuxStoreInternal( m_structMode == kObjectStore );
            if( m_locked ) {
               m_transientStore->lock();
            }
         }
         // Let the transient store create the decoration:
         const size_t nids = m_transientStore->getAuxIDs().size();
         void* result =
             m_transientStore->getDecoration( auxid, size, capacity );
         if( result && ( nids != m_transientStore->getAuxIDs().size() ) ) {
            m_auxIDs.insert( auxid );
            if( m_transientStore->isDecoration( auxid ) ) {
               m_decorIDs.insert( auxid );
            }
         }
         // Return the memory address from the transient store:
         return result;
      }
 
      // Doesn't exist yet. So let's make it:
      void* result = getData( auxid, size, capacity );
      if( m_locked ) {
         // If the container is locked, remember that this is a decoration:
         if( m_isDecoration.size() <= auxid ) {
            m_isDecoration.resize( auxid + 1 );
         }
         m_isDecoration[auxid] = ::kTRUE;
         m_decorIDs.insert( auxid );
      }
      // Return the pointer made by getData(...):
      return result;
   }

getDecorIDs()

const RAuxStore::auxid_set_t & xAOD::RAuxStore::getDecorIDs ( ) const

overridevirtual

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

Retrieves the set of decoration IDs currently associated with this store.

Returns

A constant reference to the set of decoration IDs

Implements SG::IConstAuxStore.

Definition at line 282 of file RAuxStore.cxx.

                                                            {
      return m_decorIDs;
   }

getDynamicAuxIDs()

const SG::auxid_set_t & xAOD::RAuxStore::getDynamicAuxIDs ( ) const

overridevirtual

Get the types(names) of variables created dynamically.

Returns

A const reference to the set of auxiliary IDs

Implements SG::IAuxStoreIO.

Definition at line 848 of file RAuxStore.cxx.

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

getEntry()

Int_t xAOD::RAuxStore::getEntry	(	Long64_t	entry,
		::Int_t	getall = 0
	)

Get entry from the input RNTuple.

Definition at line 155 of file RAuxStore.cxx.

                                                          {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      m_entryToLoad = 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_transientStore && ( getall != 99 ) ) {
         // Remove the transient auxiliary IDs from the internal list:
         m_auxIDs -= m_transientStore->getAuxIDs();
         m_decorIDs -= m_transientStore->getDecorIDs();
         // Delete the object:
         delete m_transientStore;
         m_transientStore = 0;
      }
 
      // Now remove the IDs of the decorations that are getting persistified:
      if( getall != 99 ) {
         for( auxid_t auxid = 0; auxid < m_isDecoration.size(); ++auxid ) {
            if( !m_isDecoration[auxid] ) {
               continue;
            }
            m_auxIDs.erase( auxid );
            m_decorIDs.erase( auxid );
         }
      }
 
      // If we don't need everything loaded, return now:
      if( !getall ) return 0;
 
      // Get all the variables at once:
      ::Int_t minEntryStatus = 1;
      for( auto& fieldPair : m_fields ) {
         if( fieldPair.second.field ) {
            minEntryStatus =
                std::min( minEntryStatus, ( fieldPair.second ).getEntry(m_entryToLoad) );
         }
      }
      return minEntryStatus;
   }

getIOData()

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

overridevirtual

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

Retrieves the input/output data for a given auxiliary ID.

It ensures that the data is properly set up and available in memory.

Parameters

auxid

The auxiliary ID for which data is requested.

Returns

A pointer to the data for the given auxiliary ID, or nullptr if the data is not available.

Implements SG::IAuxStoreIO.

Definition at line 762 of file RAuxStore.cxx.

                                                           {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // If the variable is connected to already:
      if( fieldInfosHasAuxid( auxid ) ) {
         // Return the pointer:
         return m_fields.at( auxid ).object;
      }
 
      // Check if it's in the transient store:
      if( m_transientStore && m_transientStore->getAuxIDs().test( auxid ) ) {
         return m_transientStore->getIOData( auxid );
      }
 
      // If not, try connecting to it now:
      auto this_nc ATLAS_THREAD_SAFE =
          const_cast< RAuxStore* >( this );  // locked above
      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 0;
      }
 
      // Now we should know this variable:
      if( !fieldInfosHasAuxid( auxid ) ) {
         ::Fatal( "xAOD::RAuxStore::getIOData",
                  XAOD_MESSAGE( "Internal logic error detected" ) );
         return 0;
      }
 
      // Return the pointer:
      return m_fields.at( auxid ).object;
   }

getIOType()

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

overridevirtual

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

Implements SG::IAuxStoreIO.

Definition at line 805 of file RAuxStore.cxx.

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

getSelectedAuxIDs()

SG::auxid_set_t xAOD::RAuxStore::getSelectedAuxIDs ( ) const

overridevirtual

Get the IDs of the selected aux variables.

Retrieves the selected auxiliary IDs.

Returns

A set of selected auxiliary IDs

Reimplemented from SG::IAuxStoreIO.

Definition at line 871 of file RAuxStore.cxx.

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

getVector()

const SG::IAuxTypeVector * xAOD::RAuxStore::getVector ( SG::auxid_t  auxid ) const

overridevirtual

Return vector interface for one aux data item.

Parameters

auxid

The auxiliary ID for which to retrieve the data vector

Returns

Pointer to the SG::IAuxTypeVector if it exists; otherwise, nullptr

Implements SG::IConstAuxStore.

Definition at line 232 of file RAuxStore.cxx.

                                                                       {
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // Check if the transient store already handles this variable:
      if( m_transientStore &&
          ( m_transientStore->getAuxIDs().test( auxid ) ) ) {
         return m_transientStore->getVector( auxid );
      }
 
      // Connect this auxiliary variable both to the input and output
      // if needed:
      if( ( auxid >= m_vecs.size() ) || ( !m_vecs[auxid] ) ||
          ( !fieldInfosHasAuxid( auxid ) ) ) {
         auto this_nc ATLAS_THREAD_SAFE =
             const_cast< RAuxStore* >( this );  // locked above
         if( ( !this_nc->setupInputData( auxid ).isSuccess() ) ||
             ( !this_nc->setupOutputData( auxid ).isSuccess() ) ) {
            return nullptr;
         }
      }
 
      if( fieldInfosHasAuxid( auxid ) ) {
         auto it = m_fields.find( auxid );
         if( it != m_fields.end() ) {
            const ::Int_t result =
                const_cast< RFieldInfo& >( it->second ).getEntry(m_entryToLoad);
            if( result < 0 ) {
               ::Error(
                   "xAOD::RAuxStore::getData",
                   XAOD_MESSAGE( "Couldn't read in variable %s" ),
                   SG::AuxTypeRegistry::instance().getName( auxid ).c_str() );
               return nullptr;
            }
         }
      }
 
      // Return the pointer to the data vector:
      return m_vecs[auxid];
   }

getWritableAuxIDs()

const SG::auxid_set_t & xAOD::RAuxStore::getWritableAuxIDs ( ) const

overridevirtual

Return a set of writable data identifiers.

Retrieves a set of writable auxiliary IDs.

Returns

A const reference to the set of writable auxiliary IDs

Implements SG::IAuxStore.

Definition at line 592 of file RAuxStore.cxx.

                                                           {
      return getAuxIDs();
   }

insertMove() [1/2]

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

overridevirtual

Insert contents of another store via move.

inserts and moves elements from another auxiliary store into this one, starting at the specified position.

It adjusts the size of the container accordingly.

Parameters

pos	The position at which to start inserting elements.
other	The auxiliary store from which to move elements.
ignore_in	A set of auxiliary IDs to ignore during the move.

Returns

True if the move was successful, false otherwise.

Definition at line 708 of file RAuxStore.cxx.

                                                                {
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // A sanity check:
      if( m_structMode == kObjectStore ) {
         ::Error( "xAOD::RAuxStore::insertMove",
                  XAOD_MESSAGE( "Should not have been called for single-object "
                                "store" ) );
         return false;
      }
 
      bool nomove = true;
      size_t other_size = other.size();
 
      SG::auxid_set_t ignore = ignore_in;
 
      for( SG::auxid_t id : m_auxIDs ) {
         SG::IAuxTypeVector* v_dst = nullptr;
         if( id < m_vecs.size() ) v_dst = m_vecs[id];
         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_transientStore ) {
         if( !m_transientStore->insertMove( pos, other, ignore ) )
            nomove = false;
      }
 
      return nomove;
   }

insertMove() [2/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.

isAuxIDSelected()

Bool_t xAOD::RAuxStore::isAuxIDSelected ( auxid_t  auxid ) const

private

Check if this auxiliary variable needs to go to the output.

This function checks whether a given auxiliary ID is selected.

Parameters

auxid

The auxiliary ID that should be checked

Returns

kTRUE if the variable needs to be written out, kFALSE if not

Definition at line 1611 of file RAuxStore.cxx.

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

isContainerField()

Bool_t xAOD::RAuxStore::isContainerField ( std::string  fieldName, auxid_t  auxid  ) const

private

Check if a field describes a container or a single object.

This function checks whether a given field (determined by the fieldName) corresponds to a container or a single element based on its type information.

Parameters

fieldName	The name of the field to check.
auxid	The auxiliary ID of the variable to check.

Returns

kTRUE if the field represents a container, code>kFALSE otherwise.

Definition at line 1650 of file RAuxStore.cxx.

                                                               {
      // For unknown types it doesn't matter if the field describes a
      // container or a single element.
      if( !isRegisteredType( auxid ) ) return kTRUE;
 
      auto inspector =
          RNTupleInspector::Create( m_inputNtupleName, m_inFileName );
      const auto & fieldInspector = inspector->GetFieldTreeInspector( fieldName );
 
      const std::string & typeName =
          fieldInspector.GetDescriptor().GetTypeName();
 
      const auto tClass = ::TClass::GetClass(
          typeName.c_str() );
      const std::type_info* ti = tClass->GetTypeInfo();
 
      TClass* cl = TClass::GetClass( *ti );
 
      // If there is no class associated with the field then it should be
      // a field describing a standalone object. (As it should be a
      // "primitive" field in this case.)
      if( !cl ) {
         return kFALSE;
      }
 
      // If there is a class, ask for the type_info of its type:
      const std::type_info* root_ti = cl->GetTypeInfo();
      if( !root_ti ) {
         // Type name may be saved as "basic_string<char>" rather than "string"
         // by Athena I/O.
         ::TString typeName( cl->GetName() );
         typeName.ReplaceAll( "basic_string<char>", "string" );
         ::TClass* newCl = ::TClass::GetClass( typeName );
         if( newCl ) {
            root_ti = newCl->GetTypeInfo();
         }
      }
      if( !root_ti ) {
         ::Error( "xAOD::RAuxStore::isContainerField",
                  XAOD_MESSAGE( "Couldn't get an std::type_info object out of "
                                "field \"%s\" of type \"%s\"" ),
                  m_prefix.c_str(), cl->GetName() );
         return kFALSE;
      }
 
      // Ask for the auxiliary type infos:
      const std::type_info* aux_obj_ti =
          SG::AuxTypeRegistry::instance().getType( auxid );
      if( !aux_obj_ti ) {
         ::Error( "xAOD::RAuxStore::isContainerField",
                  XAOD_MESSAGE( "Couldn't get std::type_info object for "
                                "auxiliary id: %i" ),
                  static_cast< int >( auxid ) );
         return kFALSE;
      }
      const std::type_info* aux_vec_ti =
          SG::AuxTypeRegistry::instance().getVecType( auxid );
      if( !aux_vec_ti ) {
         ::Error( "xAOD::RAuxStore::isContainerField",
                  XAOD_MESSAGE( "Couldn't get std::type_info object for "
                                "auxiliary id: %i" ),
                  static_cast< int >( auxid ) );
         return kFALSE;
      }
 
      // Check which one the ROOT type info agrees with:
      if( *root_ti == *aux_obj_ti ) {
         // This field describes a single object:
         return kFALSE;
      } else if( *root_ti == *aux_vec_ti ) {
         // This field describes a container of objects:
         return kTRUE;
      }
 
      // For enum and vector<enum> types (PFO...) the type given by
      // the aux type registry is vector<int>. We have to take it into account
      // here...
      if( cl->GetCollectionProxy() &&
          ( *aux_vec_ti == typeid( std::vector< int > ) ) ) {
         return kTRUE;
      }
 
      TClass* cl2 = lookupVectorType( cl );
      if( cl2 ) {
         if( *cl2->GetTypeInfo() == *aux_vec_ti ) return kTRUE;
      }
 
      // If we got this far, the field may have undergone schema evolution. If
      // it's one that ROOT can deal with itself, then we should still be able
      // to read the field with this code.
      TClass* aux_vec_cl =
          TClass::GetClass( Utils::getTypeName( *aux_vec_ti ).c_str() );
      if( aux_vec_cl &&
          aux_vec_cl->GetConversionStreamerInfo( cl, cl->GetClassVersion() ) ) {
         return kTRUE;
      }
      TClass* aux_obj_cl =
          TClass::GetClass( Utils::getTypeName( *aux_obj_ti ).c_str() );
      if( aux_obj_cl &&
          aux_obj_cl->GetConversionStreamerInfo( cl, cl->GetClassVersion() ) ) {
         return kFALSE;
      }
 
      // If neither, then something went wrong...
      ::Error( "xAOD::RAuxStore::isContainerField",
               XAOD_MESSAGE( "Couldn't determine if field describes a single "
                             "object or a container" ) );
      ::Error( "xAOD::RAuxStore::isContainerField",
               XAOD_MESSAGE( "ROOT type  : %s" ),
               Utils::getTypeName( *root_ti ).c_str() );
      ::Error( "xAOD::RAuxStore::isContainerField",
               XAOD_MESSAGE( "Object type: %s" ),
               Utils::getTypeName( *aux_obj_ti ).c_str() );
      ::Error( "xAOD::RAuxStore::isContainerField",
               XAOD_MESSAGE( "Vector type: %s" ),
               Utils::getTypeName( *aux_vec_ti ).c_str() );
      return kFALSE;
   }

isDecoration()

bool xAOD::RAuxStore::isDecoration ( auxid_t  auxid ) const

overridevirtual

Test if a variable is a decoration.

Parameters

auxid

The auxiliary ID for which to check if it is a decoration

Returns

True if the variable is a decoration; otherwise, false

Implements SG::IConstAuxStore.

Definition at line 375 of file RAuxStore.cxx.

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

isPrimitiveField()

Bool_t xAOD::RAuxStore::isPrimitiveField ( std::string  fieldName )

private

Check if a field holds a primitive variable or not.

This function checks whether the given field corresponds to a primitive data type based on its type information and the auxiliary ID provided.

Parameters

fieldName

The name of the field to check.

Returns

kTRUE if the field describes a primitive variable, kFALSE otherwise

Definition at line 1777 of file RAuxStore.cxx.

                                                           {
      auto inspector =
          RNTupleInspector::Create( m_inputNtupleName, m_inFileName );
      const auto& fieldInspector = inspector->GetFieldTreeInspector( fieldName );
 
      std::string typeName =
          fieldInspector.GetDescriptor().GetTypeName().c_str();
      const std::type_info* ti = nullptr;
      const auto tClass = ::TClass::GetClass(
          fieldInspector.GetDescriptor().GetTypeName().c_str() );
      ti = tClass->GetTypeInfo();
      ::EDataType dType = kOther_t;  // Default to a generic type
      dType = TDataType::GetType( *ti );
 
      // The check is made using the data type variable:
      return ( ( dType != kOther_t ) && ( dType != kNoType_t ) &&
               ( dType != kVoid_t ) );
   }

isRegisteredType()

Bool_t xAOD::RAuxStore::isRegisteredType ( auxid_t  auxid )

staticprivate

Check if the auxiliary variable has a registered type.

This function is used to test if a given auxiliary variable is known in the registry with a proper type.

Parameters

auxid

The auxiliary ID to check

Returns

kTRUE if the full type of the auxiliary property is known, kFALSE otherwise

Definition at line 1628 of file RAuxStore.cxx.

                                                     {
 
      // Cache some data:
      static SG::AuxTypeRegistry& registry ATLAS_THREAD_SAFE =
          SG::AuxTypeRegistry::instance();
      static const auxid_t sauxid =
          registry.getAuxID< SG::AuxTypePlaceholder >( "AuxTypePlaceholder" );
      static const std::type_info* const sti = registry.getVecType( sauxid );
 
      // Check if the types match:
      return ( *sti != *( registry.getVecType( auxid ) ) );
   }

linkedVector() [1/3]

const SG::IAuxTypeVector * xAOD::RAuxStore::linkedVector ( SG::auxid_t  auxid ) const

overridevirtual

Return const interface for a linked variable.

Looks up a linked variable associated with the provided auxid.

If a linked variable exists within the current vector storage (m_vecs), it returns the corresponding data vector. If not found, it checks the transient store for the linked vector.

Parameters

auxid

The auxiliary ID for which to retrieve the linked variable

Returns

Pointer to the linked variable if found; otherwise, nullptr

Reimplemented from SG::IConstAuxStore.

Definition at line 477 of file RAuxStore.cxx.

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

linkedVector() [2/3]

SG::IAuxTypeVector * xAOD::RAuxStore::linkedVector ( SG::auxid_t  auxid )

overridevirtual

Return interface for a linked variable.

(const version) Looks up a linked variable associated with the provided auxid.

If a linked variable exists within the current vector storage (m_vecs), it returns the corresponding data vector. If not found, it checks the transient store for the linked vector.

Parameters

auxid

The auxiliary ID for which to retrieve the linked variable

Returns

Pointer to the linked variable if found; otherwise, nullptr

Reimplemented from SG::IAuxStore.

Definition at line 500 of file RAuxStore.cxx.

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

linkedVector() [3/3]

virtual const IAuxTypeVector* SG::IConstAuxStore::linkedVector

inlineinherited

Return interface for a linked variable.

Parameters

auxid

The ID of the parent variable.

If auxid has a linked variable, then return the IAuxTypeVector describing it. Otherwise, return nullptr. May return nullptr unconditionally if this store does not support linked variables.

Definition at line 189 of file IConstAuxStore.h.

  { return nullptr; }

lock()

void xAOD::RAuxStore::lock ( )

overridevirtual

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

Implements SG::IConstAuxStore.

Definition at line 389 of file RAuxStore.cxx.

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

lockDecoration()

void xAOD::RAuxStore::lockDecoration ( SG::auxid_t  auxid )

overridevirtual

Lock a decoration.

Parameters

auxid

The auxiliary ID for which to lock the decoration

Implements SG::IConstAuxStore.

Definition at line 434 of file RAuxStore.cxx.

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

readFrom()

StatusCode xAOD::RAuxStore::readFrom	(	const std::string &	fileName,
		const std::string &	ntupleName
	)

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

fileName	Pointer to the file that is being read from
ntupleName	Name of the ntuple that is being read from

Returns

kTRUE if successful, kFALSE otherwise

Definition at line 103 of file RAuxStore.cxx.

                                                                 {
 
      // Remember the file name:
      m_inFileName = fileName;
      // Remember the ntuple name:
      m_inputNtupleName = ntupleName;
 
      // load the ntuple:
      try {
         // Try to access RNTuple.
         m_inNtuple = RNTupleReader::Open( m_inputNtupleName, fileName );
      } catch( ... ) {
         // Handle the case where the RNTuple is not found.
         ::Warning( "xAOD::RAuxStore::readFrom",
                    "RNTuple %s not found in file %s", m_inputNtupleName.c_str(),
                    m_inFileName.c_str() );
         m_inNtuple = nullptr;
      }
 
      // Catalogue all the fields:
      RETURN_CHECK( "xAOD::RAuxStore::readFrom", scanInputNtuple() );
 
      return StatusCode::SUCCESS;
   }

reserve()

void xAOD::RAuxStore::reserve ( size_t  size )

overridevirtual

Reserve a given size for the arrays.

Reserves space for the auxiliary data vectors.

It ensures that the vectors have enough capacity to hold the specified number of elements.

Parameters

size	The number of elements to reserve space for.

Implements SG::IAuxStore.

Definition at line 635 of file RAuxStore.cxx.

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

reset()

void xAOD::RAuxStore::reset

(

)

Reset the store.

This function resets the store to its initial state.

Definition at line 202 of file RAuxStore.cxx.

                         {
     for( auto& fieldPair : m_fields ) {
       fieldPair.second.field.release();//not a leak (coverity 17638)
     }
     m_fields.clear();  // Ensure m_fields is properly cleared
     // Remember that the input RNTuple needs to be re-scanned:
     m_inputScanned = kFALSE;
   }

resize()

bool xAOD::RAuxStore::resize ( size_t  size )

overridevirtual

Resize the arrays to a given size.

Parameters

size	The size to which the arrays should be resized

Returns

True if the resize was successful; otherwise, false

Implements SG::IAuxStore.

Definition at line 601 of file RAuxStore.cxx.

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

scanInputNtuple()

StatusCode xAOD::RAuxStore::scanInputNtuple ( )

private

Scan the input RNTuple for auxiliary fields.

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

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

Returns

kTRUE if successful, kFALSE otherwise

Definition at line 887 of file RAuxStore.cxx.

                                         {
      // Check if an input ntuple is even available:
      if( !m_inNtuple ) {
         // It's not an error if it isn't.
         return StatusCode::SUCCESS;
      }
 
      // Check if the input was already scanned:
      if( m_inputScanned ) {
         return StatusCode::SUCCESS;
      }
 
      m_inNtuple->LoadEntry( 0 );
      for( const auto& field :
#if ROOT_VERSION_CODE >= ROOT_VERSION( 6, 33, 0 )
         m_inNtuple->GetModel().GetConstFieldZero().GetSubFields()
#else
         m_inNtuple->GetModel().GetFieldZero().GetSubFields()
#endif
         ) {
         auto fieldName = field->GetQualifiedFieldName();
 
         if( m_topStore && ( fieldName == m_prefix ) ) {
            // loop over the subfields of the top store
            for( const auto& subField : 
#if ROOT_VERSION_CODE >= ROOT_VERSION( 6, 33, 0 )
                                          m_inNtuple->GetModel()
                                          .GetConstField( fieldName )
                                          .GetSubFields() 
#else
                                          m_inNtuple->GetModel()
                                          .GetField( fieldName )
                                          .GetSubFields() 
#endif                   
                                            ) {
               auto fieldName = subField->GetQualifiedFieldName();
               auto auxName = fieldName.substr( fieldName.find( "." ) + 1 );
 
               // Skip this entry if it refers to a base class:
               if( ( auxName.rfind( "xAOD::", 0 ) == 0 ) ||
                   ( auxName.rfind( "SG::", 0 ) == 0 ) ||
                   ( auxName.rfind( "ILockable", 0 ) == 0 ) ) {
                  continue;
               }
 
               if( !Utils::fieldExists( fieldName, *m_inNtuple ) ) {
                  ::Fatal( "xAOD::RAuxStore::scanInputNtuple",
                           XAOD_MESSAGE( "Logic error detected" ) );
                  return StatusCode::FAILURE;
               }
 
               RETURN_CHECK( "xAOD::RAuxStore::scanInputNtuple",
                             setupAuxField( fieldName, auxName, kTRUE ) );
            }
            // Don't check the rest of the loop's body:
            continue;
         }
 
         // if fieldname doesnt start with the value of m_dynPrefix, skip
         if( fieldName.rfind( m_dynPrefix, 0 ) != 0 ) {
            continue;
         }
         if( fieldName == m_dynPrefix ) {
            ::Warning( "xAOD::RAuxStore::scanInputNtuple",
                       "Dynamic field with empty name found on container: %s",
                       m_prefix.c_str() );
            continue;
         }
         // The auxiliary property name:
         const auto auxName = fieldName.substr( fieldName.find( ":" ) + 1 );
         // Leave the rest up to the function that is shared with the
         // dynamic fields:
         RETURN_CHECK( "xAOD::RAuxStore::scanInputNtuple",
                       setupAuxField( fieldName, auxName, kFALSE ) );
      }
      // the input was successfully scanned:
      m_inputScanned = kTRUE;
 
      return StatusCode::SUCCESS;
   }

selectAux()

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

virtual

Select dynamic auxiliary attributes for writing.

Selects the auxiliary attributes specified in the input set.

Parameters

attributes

A set of attribute names to be selected

Definition at line 859 of file RAuxStore.cxx.

                                                                    {
 
      // Guard against multi-threaded execution:
      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 xAOD::AuxContainerBase, xAOD::AuxInfoBase, and SG::AuxStoreInternal.

Definition at line 173 of file IAuxStore.h.

  { return false; }

setupAuxField()

StatusCode xAOD::RAuxStore::setupAuxField ( const std::string &  fieldName, const std::string &  auxName, ::Bool_t  isStaticField  )

private

Register one input field as an available auxiliary variable.

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

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

Parameters

fieldName	The name of the field in the ntuple
auxName	The name of the auxiliary field
isStaticField	kTRUE if this is a static field, and kFALSE if it's a dynamic one

Returns

kTRUE if successful, kFALSE if not

Definition at line 1456 of file RAuxStore.cxx.

                                                               {
 
      std::string expectedClassName;
      const std::type_info* ti = auxFieldType( fieldName, auxName, isStaticField );
 
      // Get the registry:
      SG::AuxTypeRegistry& registry = SG::AuxTypeRegistry::instance();
 
      // Check if the registry already knows this variable name. If yes, let's
      // use the type known by the registry. To be able to deal with simple
      // schema evolution in dynamic fields.
      const auxid_t regAuxid = registry.findAuxID( auxName );
      if( regAuxid != SG::null_auxid ) {
         m_auxIDs.insert( regAuxid );
         return StatusCode::SUCCESS;
      }
 
      // If we didn't find a type_info for the field
      if( !ti ) {
         return StatusCode::SUCCESS;
      }
 
      SG::AuxVarFlags flags = SG::AuxVarFlags::SkipNameCheck;
      SG::auxid_t linkedAuxId = SG::null_auxid;
 
      if( SG::AuxTypeRegistry::isLinkedName( auxName ) ) {
         flags |= SG::AuxVarFlags::Linked;
      } else if( SG::AuxTypeRegistry::classNameHasLink( expectedClassName ) ) {
         std::string linkedAttr = SG::AuxTypeRegistry::linkedName( auxName );
         std::string linkedFieldName =
             SG::AuxTypeRegistry::linkedName( fieldName );
         const std::type_info* linkedTi = nullptr;
         if( Utils::fieldExists(  linkedFieldName, *m_inNtuple ) ) {
            linkedTi = auxFieldType(  std::move(linkedFieldName), linkedAttr, isStaticField );
         }
         if( linkedTi ) {
            linkedAuxId = registry.getAuxID(
                *linkedTi, linkedAttr, "",
                SG::AuxVarFlags::SkipNameCheck | SG::AuxVarFlags::Linked );
         }
         if( linkedAuxId == SG::null_auxid ) {
            ::Error( "xAOD::RAuxStore::setupAuxField",
                     "Could not find linked variable for %s type %s",
                     auxName.c_str(), expectedClassName.c_str() );
         }
      }
 
      // Check for an auxiliary ID for this field:
      auxid_t auxid = registry.getAuxID( *ti, auxName, "", flags, linkedAuxId );
 
      // First try to find a compiled factory for the vector type:
      if( auxid == SG::null_auxid ) {
         // Construct the name of the factory's class:
         // But be careful --- if we don't exactly match the name
         // in TClassTable, then we may trigger autoparsing.  Besides the
         // resource usage that implies, that can lead to crashes in dbg
         // builds due to cling bugs.
         std::string typeName = Utils::getTypeName( *ti );
         if( typeName.starts_with( "std::vector<" ) ) typeName.erase( 0, 5 );
         std::string factoryClassName =
             "SG::AuxTypeVectorFactory<" + typeName + ",allocator<" + typeName;
         if( factoryClassName[factoryClassName.size() - 1] == '>' ) {
            factoryClassName += ' ';
         }
         factoryClassName += "> >";
 
         // Look for the dictionary of this type:
         ::TClass* factoryClass = TClass::GetClass( factoryClassName.c_str() );
         if( factoryClass && factoryClass->IsLoaded() ) {
            ::TClass* baseClass =
                ::TClass::GetClass( "SG::IAuxTypeVectorFactory" );
            if( baseClass && baseClass->IsLoaded() ) {
               const Int_t offset =
                   factoryClass->GetBaseClassOffset( baseClass );
               if( offset >= 0 ) {
                  void* factoryVoidPointer = factoryClass->New();
                  if( factoryVoidPointer ) {
                     unsigned long tmp = reinterpret_cast< unsigned long >(
                                             factoryVoidPointer ) +
                                         offset;
                     SG::IAuxTypeVectorFactory* factory =
                         reinterpret_cast< SG::IAuxTypeVectorFactory* >( tmp );
                     registry.addFactory(
                         *ti, *factory->tiAlloc(),
                         std::unique_ptr< SG::IAuxTypeVectorFactory >(
                             factory ) );
                     auxid = registry.getAuxID( *ti, auxName, "", flags,
                                                linkedAuxId );
                  }
               }
            }
         }
      }
 
      // If that didn't succeed, let's assign a generic factory to this type:
      if( auxid == SG::null_auxid && linkedAuxId == SG::null_auxid ) {
         // Construct the name of the vector type:
         std::string vectorClassName =
             "std::vector<" + Utils::getTypeName( *ti );
         if( vectorClassName[vectorClassName.size() - 1] == '>' ) {
            vectorClassName += ' ';
         }
         vectorClassName += '>';
 
         // Get the dictionary for the type:
         ::TClass* vectorClass = ::TClass::GetClass( vectorClassName.c_str() );
         if( vectorClass && vectorClass->IsLoaded() ) {
            auto factory = std::make_unique< TAuxVectorFactory >( vectorClass );
            if( factory->tiAlloc() ) {
               const std::type_info* tiAlloc = factory->tiAlloc();
               registry.addFactory( *ti, *tiAlloc, std::move( factory ) );
            } else {
               std::string tiAllocName = factory->tiAllocName();
               registry.addFactory( *ti, tiAllocName, std::move( factory ) );
            }
            auxid = registry.getAuxID( *ti, auxName, "",
                                       SG::AuxVarFlags::SkipNameCheck );
         } else {
            ::Warning( "xAOD::RAuxStore::setupAuxField",
                       "Couldn't find dictionary for type: %s",
                       vectorClassName.c_str() );
         }
      }
      // Check if we succeeded:
      if( auxid == SG::null_auxid ) {
         if( linkedAuxId != SG::null_auxid ) {
            ::Error(
                "xAOD::RAuxStore::setupAuxField",
                XAOD_MESSAGE( "Dynamic ROOT vector factory not implemented for "
                              "linked types; field "
                              "\"%s\"" ),
                fieldName.c_str() );
         } else {
            ::Error( "xAOD::RAuxStore::setupAuxField",
                     XAOD_MESSAGE( "Couldn't assign auxiliary ID to field "
                                   "\"%s\"" ),
                     fieldName.c_str() );
         }
         return StatusCode::FAILURE;
      }
 
      // Remember the auxiliary ID:
      m_auxIDs.insert( auxid );
 
      return StatusCode::SUCCESS;
   }

setupInputData()

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

private

Connect a variable to the input tree.

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

kTRUE if successful, kFALSE otherwise

Definition at line 974 of file RAuxStore.cxx.

                                                       {
      // Return right away if we already know that the field is not found:
      if( fieldInfosHasAuxid( auxid ) &&
          m_fields[auxid].status == RAuxStore::RFieldInfo::NotFound ) {
         return StatusCode::RECOVERABLE;
      }
 
      // Make sure the internal storage is large enough:
      if( m_vecs.size() <= auxid ) {
         m_vecs.resize( auxid + 1 );
      }
 
      // Check if we need to do anything:
      if( m_vecs[auxid] && fieldInfosHasAuxid( auxid ) ) {
         return StatusCode::SUCCESS;
      }
 
      // A little sanity check:
      if( !m_inNtuple ) {
         ::Error( "xAOD::RAuxStore::setupInputData",
                  XAOD_MESSAGE( "No input RNTuple set up!" ) );
         return StatusCode::FAILURE;
      }
 
      // Another sanity check:
      if( m_vecs[auxid] || fieldInfosHasAuxid( auxid ) ) {
         ::Error( "xAOD::RAuxStore::setupInputData",
                  XAOD_MESSAGE( "The internal variables of the object got "
                                "messed up?!?" ) );
         return StatusCode::FAILURE;
      }
 
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
      // Get the property name:
      const TString statFieldName = m_prefix + r.getName( auxid ).c_str();
      const TString dynFieldName = m_dynPrefix + r.getName( auxid ).c_str();
 
      // Check if the field exists:
      TString fieldName = statFieldName;
#if ROOT_VERSION_CODE >= ROOT_VERSION( 6, 33, 0 )
      std::unique_ptr< RNTupleView< void > >
#else
      std::unique_ptr< RNTupleView< void, true > >
#endif
      field;
      if( !Utils::fieldExists( statFieldName.Data(), *m_inNtuple ) ) {
         if( !Utils::fieldExists( dynFieldName.Data(), *m_inNtuple ) ) {
            m_fields[auxid].status = RAuxStore::RFieldInfo::NotFound;
            return StatusCode::RECOVERABLE;
         }
         // We have a dynamic field:
         fieldName = dynFieldName;
      }
 
      // Check if it's a "primitive field":
      const Bool_t primitiveField = isPrimitiveField( fieldName.Data() );
      // Check if it's a "container field":
      const Bool_t containerField =
          ( primitiveField ? kFALSE
                           : isContainerField( fieldName.Data(), auxid ) );
 
      // Set the structure mode if it has not been defined externally:
      if( m_structMode == kUndefinedStore ) {
         m_structMode = ( containerField ? kContainerStore : kObjectStore );
      }
 
      // Check that the field type makes sense:
      if( ( containerField && ( m_structMode != kContainerStore ) &&
            !r.isLinked( auxid ) ) ||
          ( ( !containerField ) && ( m_structMode != kObjectStore ) ) ) {
         ::Error( "xAOD::RAuxStore::setupInputData",
                  XAOD_MESSAGE( "Field type and requested structure mode "
                                "differ for field: %s" ),
                  fieldName.Data() );
         return StatusCode::FAILURE;
      }
      // Get the field's type:
      auto inspector =
          RNTupleInspector::Create( m_inputNtupleName, m_inFileName );
      const auto & fieldInspector = inspector->GetFieldTreeInspector(
          Utils::getFirstFieldMatch( *m_inNtuple, fieldName.Data() ) );
 
      std::string typeName =
          fieldInspector.GetDescriptor().GetTypeName().c_str();
      const std::type_info* ti = nullptr;
      const auto tClass = ::TClass::GetClass(
          fieldInspector.GetDescriptor().GetTypeName().c_str() );
      ti = tClass->GetTypeInfo();
      TClass* clDummy = TClass::GetClass( *ti );
 
      ::EDataType dType = kOther_t;  // Default to a generic type
      dType = TDataType::GetType( *ti );
 
      // Get the property type:
      const std::type_info* fieldType = 0;
      if( 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:
         fieldType = ( clDummy ? clDummy->GetTypeInfo()
                               : &( Utils::getTypeInfo( dType ) ) );
      }
      if( !fieldType ) {
         ::Error( "xAOD::RAuxStore::setupInputData",
                  XAOD_MESSAGE( "Can't read/copy variable %s (%s)" ),
                  fieldName.Data(), clDummy->GetName() );
         return StatusCode::RECOVERABLE;
      }
      const TString fieldTypeName = Utils::getTypeName( *fieldType ).c_str();
 
      // Check if we have the needed dictionary for an object field:
      ::TClass* fieldClass = 0;
      if( !primitiveField ) {
         // Get the property's class:
         fieldClass = ::TClass::GetClass( *fieldType, kTRUE, kTRUE );
         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( isRegisteredType( auxid ) ) {
         m_vecs[auxid] = r.makeVector( auxid, (size_t)0, (size_t)0 ).release();
         if( !containerField ) {
            m_vecs[auxid]->resize( 1 );
         }
         if( clDummy &&
             strncmp( clDummy->GetName(), "SG::PackedContainer<", 20 ) == 0 ) {
            SG::IAuxTypeVector* packed = m_vecs[auxid]->toPacked().release();
            std::swap( m_vecs[auxid], packed );
            delete packed;
         }
      } else {
         ::Error( "xAOD::RAuxStore::setupInputData",
                  XAOD_MESSAGE( "Couldn't create in-memory vector for "
                                "variable %s (%i)" ),
                  fieldName.Data(), static_cast< int >( auxid ) );
         return StatusCode::FAILURE;
      }
 
      if( m_inModel == nullptr ) {
         m_inModel = RNTupleModel::Create();
      }
 
      if( primitiveField ) {
         auto fieldResult = RFieldBase::Create( fieldName.Data(),
                                                fieldTypeName.Data() );
         if( fieldResult ) {
            auto field = fieldResult.Unwrap();
            m_inModel->AddField( std::move( field ) );
         }
      } else {
         RETURN_CHECK(
             "xAOD::RAuxStore::setupInputData",
             addVectorField( fieldName.Data(), fieldTypeName.Data(), kTRUE ) );
      }
 
      // Since we just moved the model, we need to reset it
      m_inModel = RNTupleModel::Create();
      RETURN_CHECK(
          "xAOD::RAuxStore::setupInputData",
          addVectorField( fieldName.Data(), fieldTypeName.Data(), kTRUE ) );
 
      m_fields[auxid].field = 
#if ROOT_VERSION_CODE >= ROOT_VERSION( 6, 33, 0 )
      std::make_unique< RNTupleView< void > > (
#else
      std::make_unique< RNTupleView< void, true > >(
#endif
         m_inNtuple->GetView< void >( fieldName.Data(), nullptr ) 
      );
      m_fields[auxid].status = RAuxStore::RFieldInfo::Initialized;
      m_fields[auxid].fieldTypeName = fieldTypeName.Data();
      m_fields[auxid].ntupleName = m_inputNtupleName;
      m_fields[auxid].object = ( containerField ? m_vecs[auxid]->toVector()
                                                : m_vecs[auxid]->toPtr() );
      m_fields[auxid].typeInfo = const_cast< std::type_info* >( fieldType );
 
      // Remember which variable got created:
      m_auxIDs.insert( auxid );
 
      // Check if we just replaced a generic object:
      if( 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( auxid_t i = 0; i < m_vecs.size(); ++i ) {
            // Check if we have this aux ID:
            if( !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( isRegisteredType( i ) ) {
               ::Error( "xAOD::RAuxStore::setupInputData",
                        XAOD_MESSAGE( "Internal logic error!" ) );
               continue;
            }
            // Okay, we do need to remove this object:
            delete m_vecs[i];
            m_vecs[i] = 0;
            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 ( auxid_t  auxid )

private

Connect a variable to the output ntuple.

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

kTRUE if the operation was successful, kFALSE if not

Definition at line 1207 of file RAuxStore.cxx.

                                                        {
      // Check whether we need to do anything:
      if( !m_outNtuple ) 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_vecs.size() <= auxid ) {
         m_vecs.resize( auxid + 1 );
      }
 
      // 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_vecs[auxid] ) && m_transientStore &&
          ( m_transientStore->getAuxIDs().test( auxid ) ) ) {
 
         // Get the variable from the transient store:
         const void* pptr = m_transientStore->getData( auxid );
         if( !pptr ) {
            ::Fatal( "xAOD::RAuxStore::setupOutputData",
                     XAOD_MESSAGE( "Internal logic error detected" ) );
            return StatusCode::FAILURE;
         }
 
         // The registry:
         SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
 
         // Inside it's own scope to ensure that the lock is released
         {
            std::lock_guard<std::mutex> lock(m_mutex1);
            // Create the new object:
            m_vecs[auxid] = reg.makeVector(auxid, m_size, m_size).release();
         }
         void* ptr = 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;
         }
 
         // Finally, do the copy:
         factory->copy( auxid, SG::AuxVectorInterface( *this ), 0,
                        SG::AuxVectorInterface( *m_transientStore ), 0,
                        m_size );
 
         // And now remember that this is a decoration:
         if( m_isDecoration.size() <= auxid ) {
            m_isDecoration.resize( auxid + 1 );
         }
         m_isDecoration[auxid] = ::kTRUE;
      }
 
      // Check if we know about this variable to be on the input,
      // but haven't connected to it yet:
      if( ( m_auxIDs.test( auxid ) ) && ( !m_vecs[auxid] ) &&
          ( !fieldInfosHasAuxid( auxid ) ) ) {
         RETURN_CHECK( "xAOD::RAuxStore::setupOutputData",
                       setupInputData( auxid ) );
      }
 
      // Check that we know the store's type:
      if( ( m_structMode != kContainerStore ) &&
          ( m_structMode != kObjectStore ) ) {
         ::Error( "xAOD::RAuxStore::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_vecs[auxid] ) {
         m_vecs[auxid] = SG::AuxTypeRegistry::instance()
                             .makeVector( auxid, (size_t)0, (size_t)0 )
                             .release();
         if( m_structMode == kObjectStore ) {
            m_vecs[auxid]->resize( 1 );
         }
      }
      if( !m_outNtuple ) {
      }
 
      // if we have not called this method before, the model will be null
      if( m_outModel == nullptr ) {
         m_outModel = RNTupleModel::Create();
      }
 
      const TString fieldName =
          m_dynPrefix + SG::AuxTypeRegistry::instance().getName( auxid );
      const std::type_info* fieldType =
          m_structMode == kContainerStore
              ? SG::AuxTypeRegistry::instance().getVecType( auxid )
              : SG::AuxTypeRegistry::instance().getType( auxid );
      const TString fieldTypeName = Utils::getTypeName( *fieldType ).c_str();
      // If it is a primitive field, it only has 1 character (e.g. 'f' for
      // float)
      const Bool_t isPrimitiveField = ( strlen( fieldTypeName.Data() ) == 1 );
 
      if( isPrimitiveField ) {
         auto fieldResult = RFieldBase::Create( fieldName.Data(),
                                                fieldTypeName.Data() );
         if( fieldResult ) {
            auto field = fieldResult.Unwrap();
            m_outModel->AddField( std::move( field ) );
         }
      } else {
         RETURN_CHECK( "xAOD::RAuxStore::setupOutputData",
                       addVectorField( fieldName.Data(),
                                       fieldTypeName.Data(), kFALSE ) );
      }
 
      auto file = ::TFile::Open( m_outFileName.c_str(), "UPDATE" );
 
      // Inside it's own scope to ensure it is not open when we try to read from
      // it
      {
         auto ntuple =
             RNTupleWriter::Append( std::move( m_outModel ),
                                    m_outputNtupleName, *file );
         ntuple->Fill();
      }
 
      // Since we just moved the model, we need to reset it
      m_outModel = RNTupleModel::Create();
      RETURN_CHECK( "xAOD::RAuxStore::setupOutputData",
                    addVectorField( fieldName.Data(),
                                    fieldTypeName.Data(), kFALSE ) );
      auto ntuple = RNTupleReader::Open( m_outputNtupleName, m_outFileName );
      m_fields[auxid].field = 
#if ROOT_VERSION_CODE >= ROOT_VERSION( 6, 33, 0 )
      std::make_unique< RNTupleView< void > >
#else
      std::make_unique< RNTupleView< void, true > >
#endif
      ( ntuple->GetView< void >( fieldName, nullptr ) );
      m_fields[auxid].status = RAuxStore::RFieldInfo::Initialized;
      m_fields[auxid].fieldTypeName = fieldTypeName.Data();
      m_fields[auxid].ntupleName = m_inputNtupleName;
      m_fields[auxid].object =
          ( m_structMode == kObjectStore ? m_vecs[auxid]->toVector()
                                         : m_vecs[auxid]->toPtr() );
      m_fields[auxid].typeInfo = const_cast< std::type_info* >( fieldType );
 
      // Also, remember that we now handle this variable:
      m_auxIDs.insert( auxid );
      // We were successful:
      return StatusCode::SUCCESS;
   }

shift()

void xAOD::RAuxStore::shift ( size_t  pos, ptrdiff_t  offs  )

overridevirtual

Shift the contents of the stored arrays.

Shifts the elements in the auxiliary data vectors by a specified offset.

It adjusts the size of the container accordingly.

Parameters

pos	The position at which to start shifting.
offs	The offset by which to shift the elements.

Implements SG::IAuxStore.

Definition at line 666 of file RAuxStore.cxx.

                                                     {
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex1 );
 
      // A sanity check:
      if( m_structMode == kObjectStore ) {
         ::Error( "xAOD::RAuxStore::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_size ) &&
          ( offs < 0 ) ) {
         m_size = 0;
      } else {
         m_size += offs;
      }
 
      for( SG::IAuxTypeVector* v : m_vecs ) {
         if( v && !v->isLinked() ) {
            v->shift( pos, offs );
         }
      }
 
      if( m_transientStore ) {
         m_transientStore->shift( pos, offs );
      }
 
      return;
   }

size()

size_t xAOD::RAuxStore::size ( ) const

overridevirtual

Return the number of elements in the store.

Returns

The number of elements in the store

Implements SG::IConstAuxStore.

Definition at line 445 of file RAuxStore.cxx.

                                {
      // First, try to find a managed vector in the store:
      for( SG::auxid_t id : m_auxIDs ) {
         // Make sure that we are still within the bounds of our vector:
         if( id >= m_vecs.size() ) break;
         // Skip non-existent or linked objects:
         if( !m_vecs[id] || m_vecs[id]->isLinked() ) continue;
         // Ask the vector for its size:
         const size_t size = 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_transientStore ) {
         return m_transientStore->size();
      }
 
      // Apparently the store is empty:
      return 0;
   }

structMode()

RAuxStore::EStructMode xAOD::RAuxStore::structMode

(

)

const

Return the structure mode of the object.

This function gets the structure mode of the object.

Returns

The structure mode of the object

Definition at line 91 of file RAuxStore.cxx.

                                                    {
 
      return m_structMode;
   }

writeTo()

StatusCode xAOD::RAuxStore::writeTo	(	const std::string &	fileName,
		const std::string &	ntupleName
	)

Connect the object to an output RNTuple.

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

Parameters

fileName	Pointer to the file that is being written to
ntupleName	Name of the ntuple that is being written to

Returns

kTRUE if successful, kFALSE otherwise

Definition at line 136 of file RAuxStore.cxx.

                                                                 {
      // Look for any auxiliary fields that have not been connected to yet:
      RETURN_CHECK( "xAOD::RAuxStore::writeTo", scanInputNtuple() );
      m_outFileName = fileName;
      m_outputNtupleName = ntupleName;
      m_outNtuple = RNTupleReader::Open( m_outputNtupleName, m_outFileName );
 
      // 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 auxid_set_t selAuxIDs = getSelectedAuxIDs();
      for( SG::auxid_t id : selAuxIDs ) {
         RETURN_CHECK( "xAOD::RAuxStore::writeTo", setupOutputData( id ) );
      }
 
      return StatusCode::SUCCESS;
   }

Member Data Documentation

m_auxIDs

auxid_set_t xAOD::RAuxStore::m_auxIDs

private

Internal list of variable IDs handled currently by the object.

Definition at line 205 of file RAuxStore.h.

m_decorIDs

auxid_set_t xAOD::RAuxStore::m_decorIDs

private

Definition at line 206 of file RAuxStore.h.

m_dynPrefix

std::string xAOD::RAuxStore::m_dynPrefix

private

Dynamic prefix for the field names.

Definition at line 184 of file RAuxStore.h.

m_entryToLoad

::Long64_t xAOD::RAuxStore::m_entryToLoad

private

The entry to load from the ntuple.

Definition at line 237 of file RAuxStore.h.

m_fields

std::map< auxid_t, RFieldInfo > xAOD::RAuxStore::m_fields

private

A way to acces an representation of a field with an auxid.

Definition at line 271 of file RAuxStore.h.

m_inFileName

std::string xAOD::RAuxStore::m_inFileName

private

The input file that we are reading from.

Definition at line 225 of file RAuxStore.h.

m_inModel

std::unique_ptr< RNTupleModel > xAOD::RAuxStore::m_inModel

private

The model of the input ntuple.

Definition at line 235 of file RAuxStore.h.

m_inNtuple

std::unique_ptr< RNTupleReader > xAOD::RAuxStore::m_inNtuple

private

The ntuple being read from.

Definition at line 192 of file RAuxStore.h.

m_inputNtupleName

std::string xAOD::RAuxStore::m_inputNtupleName

private

The name of the ntuple that we are reading from.

Definition at line 229 of file RAuxStore.h.

m_inputScanned

::Bool_t xAOD::RAuxStore::m_inputScanned

private

"Scan status" of the input RNTuple

Definition at line 197 of file RAuxStore.h.

m_isDecoration

std::vector< ::Bool_t > xAOD::RAuxStore::m_isDecoration

private

Flags items as decorations.

Definition at line 215 of file RAuxStore.h.

m_locked

::Bool_t xAOD::RAuxStore::m_locked

private

Is this container locked?

Definition at line 213 of file RAuxStore.h.

m_mutex1

mutex_t xAOD::RAuxStore::m_mutex1

mutableprivate

Mutexes object used for multithreaded synchronisation.

Definition at line 222 of file RAuxStore.h.

m_mutex2

mutex_t xAOD::RAuxStore::m_mutex2

private

Definition at line 222 of file RAuxStore.h.

m_outFileName

std::string xAOD::RAuxStore::m_outFileName

private

The output file that we are writing to.

Definition at line 227 of file RAuxStore.h.

m_outModel

std::unique_ptr< RNTupleModel > xAOD::RAuxStore::m_outModel

private

The model of the output ntuple.

Definition at line 233 of file RAuxStore.h.

m_outNtuple

std::unique_ptr< RNTupleReader > xAOD::RAuxStore::m_outNtuple

private

The the ntuple being written to.

Definition at line 194 of file RAuxStore.h.

m_outputNtupleName

std::string xAOD::RAuxStore::m_outputNtupleName

private

The name of the ntuple that we are writing to.

Definition at line 231 of file RAuxStore.h.

m_prefix

std::string xAOD::RAuxStore::m_prefix

private

Static prefix for the field names.

Definition at line 182 of file RAuxStore.h.

m_selection

AuxSelection xAOD::RAuxStore::m_selection

private

Object helping to select which auxiliary variables to write.

Definition at line 200 of file RAuxStore.h.

m_size

std::size_t xAOD::RAuxStore::m_size {}

private

The current size of the container being described.

Definition at line 210 of file RAuxStore.h.

m_structMode

EStructMode xAOD::RAuxStore::m_structMode

private

The "structural" mode of the object.

Definition at line 189 of file RAuxStore.h.

m_topStore

::Bool_t xAOD::RAuxStore::m_topStore

private

Flag stating whether this is a "top store".

Definition at line 186 of file RAuxStore.h.

m_transientStore

SG::AuxStoreInternal* xAOD::RAuxStore::m_transientStore {}

private

Store for the in-memory-only variables.

Definition at line 202 of file RAuxStore.h.

m_vecs

std::vector< SG::IAuxTypeVector* > xAOD::RAuxStore::m_vecs

private

Variables handled currently by the object.

Definition at line 208 of file RAuxStore.h.

supportsThinning

constexpr 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