EventInfo_v1.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// System include(s):
#include <atomic>
#include <print>
#include <format>
#include <stdexcept>
 
// EDM include(s):
#include "xAODCore/AuxStoreAccessorMacros.h"
#include "AthContainers/tools/AtomicDecorator.h"
#include "CxxUtils/stall.h"
 
// Local include(s):
#include "xAODEventInfo/versions/EventInfo_v1.h"
#include "xAODEventInfo/EventInfoContainer.h"
#include "EventInfoAccessors_v1.h"
 
#ifndef XAOD_STANDALONE
# include "StoreGate/StoreGateSvc.h"
# include "AthenaKernel/proxyDictFromEventContext.h"
#endif
 
namespace xAODEventInfoPrivate {

   void pileupUnsetHook() {
      static std::atomic< bool > uninitPileupAccessPrinted = false;
      if( ! uninitPileupAccessPrinted ) {
         std::println( "xAOD::EventInfo WARNING Uninitialised pileup value was "
                       "accessed.\n"
                       "                        Debug it by breaking on "
                       "xAODEventInfoPrivate::pileupUnsetHook function calls!" );
         uninitPileupAccessPrinted = true;
      }
      return;
   }
 
   // register attributes' types early (before I/O) for schema evolution
   static const SG::Accessor< uint64_t > accEvNum( "eventNumber" );
   static const SG::Accessor< uint64_t > accMcEvNum( "mcEventNumber" );
   static const SG::Accessor< uint64_t > accLow( "pileUpMixtureIDLowBits" );
   static const SG::Accessor< uint64_t > accHigh( "pileUpMixtureIDHighBits" );
 
} // private namespace
 
namespace xAOD {
 
   EventInfo_v1::EventInfo_v1()
      : SG::AuxElement(), m_streamTags(),
        m_subEvents(), m_evtStore( nullptr ) {
 
   }
 
   EventInfo_v1::EventInfo_v1( const EventInfo_v1& parent )
      : SG::AuxElement(parent), m_streamTags(),
        m_subEvents(),
        m_evtStore( parent.m_evtStore ) {
 
      makePrivateStore( parent );
   }
 
   EventInfo_v1& EventInfo_v1::operator=( const EventInfo_v1& rhs ) {
 
      if (&rhs != this) {
        // Clear out the caches:
        m_streamTags.store (std::vector< StreamTag >());
        m_streamTags.reset();
        m_subEvents.store (std::vector< SubEvent >());
        m_subEvents.reset();
 
        // Copy the event store pointer:
        m_evtStore = rhs.m_evtStore;
 
        // Copy the auxiliary variables:
        SG::AuxElement::operator=( rhs );
      }
 
      // Return this object:
      return *this;
   }

   //
   //              Implementation of the basic event properties
   //
 
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         runNumber, setRunNumber )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint64_t,
                                         eventNumber, setEventNumber )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         lumiBlock, setLumiBlock )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         timeStamp, setTimeStamp )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         timeStampNSOffset,
                                         setTimeStampNSOffset )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         bcid, setBCID )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         detectorMask0, setDetectorMask0 )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         detectorMask1, setDetectorMask1 )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         detectorMask2, setDetectorMask2 )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         detectorMask3, setDetectorMask3 )
 
   uint64_t EventInfo_v1::detectorMask() const {
 
      return ( ( static_cast< uint64_t >( detectorMask1() ) << 32 ) |
               detectorMask0() );
   }
 
   void EventInfo_v1::setDetectorMask( uint32_t mask0, uint32_t mask1 ) {
 
      setDetectorMask0( mask0 );
      setDetectorMask1( mask1 );
      return;
   }
 
   void EventInfo_v1::setDetectorMask( uint64_t mask ) {
 
      setDetectorMask0( static_cast< uint32_t >( mask & 0xffffffff ) );
      setDetectorMask1( static_cast< uint32_t >( ( mask >> 32 ) &
                                                 0xffffffff ) );
      return;
   }
 
   uint64_t EventInfo_v1::detectorMaskExt() const {
 
      return ( ( static_cast< uint64_t >( detectorMask3() ) << 32 ) |
               detectorMask2() );
   }
 
   void EventInfo_v1::setDetectorMaskExt( uint32_t mask2, uint32_t mask3 ) {
 
      setDetectorMask2( mask2 );
      setDetectorMask3( mask3 );
      return;
   }
 
   void EventInfo_v1::setDetectorMaskExt( uint64_t mask ) {
 
      setDetectorMask2( static_cast< uint32_t >( mask & 0xffffffff ) );
      setDetectorMask3( static_cast< uint32_t >( ( mask >> 32 ) &
                                                 0xffffffff ) );
      return;
   }
 
   //

   //
   //              Implementation of the event type properties
   //
 
   AUXSTORE_OBJECT_SETTER_AND_GETTER( EventInfo_v1,
                                      EventInfo_v1::DetDescrTags_t,
                                      detDescrTags, setDetDescrTags )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         mcChannelNumber, setMCChannelNumber )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint64_t,
                                         mcEventNumber, setMCEventNumber )
   AUXSTORE_OBJECT_SETTER_AND_GETTER( EventInfo_v1, std::vector< float >,
                                      mcEventWeights, setMCEventWeights )
 
   float EventInfo_v1::mcEventWeight( size_t i ) const {
 
      // Throw an exception when asked for an impossible index:
      return mcEventWeights().at( i );
   }
 
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         eventTypeBitmask, setEventTypeBitmask )
 
   bool EventInfo_v1::eventType( EventType type ) const {
 
      return ( eventTypeBitmask() & static_cast< uint32_t >( type ) );
   }
 
   //

   //
   //            Implementation of the trigger related properties
   //
 
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         statusElement, setStatusElement )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t,
                                         extendedLevel1ID, setExtendedLevel1ID )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint16_t,
                                         level1TriggerType,
                                         setLevel1TriggerType )
 
   EventInfo_v1::StreamTag::StreamTag( const std::string& name,
                                       const std::string& type,
                                       bool obeysLumiblock,
                                       const std::set< uint32_t >& robs,
                                       const std::set< uint32_t >& dets )
   : m_name( name ), m_type( type ), m_obeysLumiblock( obeysLumiblock ),
      m_robs( robs ), m_dets( dets ) {
 
   }
 
   const std::string& EventInfo_v1::StreamTag::name() const {
 
      return m_name;
   }
 
   const std::string& EventInfo_v1::StreamTag::type() const {
 
      return m_type;
   }
 
   bool EventInfo_v1::StreamTag::obeysLumiblock() const {
 
      return m_obeysLumiblock;
   }
 
   const std::set< uint32_t >& EventInfo_v1::StreamTag::robs() const {
 
      return m_robs;
   }
 
   const std::set< uint32_t >& EventInfo_v1::StreamTag::dets() const {
 
      return m_dets;
   }
 
   //
   // Accessor objects for the stream properties:
   //
   static const EventInfo_v1::Accessor< std::vector< std::string > >
      names( "streamTagNames" );
   static const EventInfo_v1::Accessor< std::vector< std::string > >
      types( "streamTagTypes" );
   static const EventInfo_v1::Accessor< std::vector< char > >
      olb( "streamTagObeysLumiblock" );
   static const EventInfo_v1::Accessor< std::vector< std::set< uint32_t > > >
      robsets( "streamTagRobs" );
   static const EventInfo_v1::Accessor< std::vector< std::set< uint32_t > > >
      detsets( "streamTagDets" );
 
   const std::vector< EventInfo_v1::StreamTag >&
   EventInfo_v1::streamTags() const {
 
      // Cache the new information if necessary:
      if( !m_streamTags.isValid() ) {
         std::vector< StreamTag > tags;
 
         // A little sanity check:
         if( ( names( *this ).size() != types( *this ).size() ) ||
             ( names( *this ).size() != olb( *this ).size() ) ||
             ( robsets.isAvailable( *this ) &&
               ( names( *this ).size() != robsets( *this ).size() ) ) ||
             ( detsets.isAvailable( *this ) &&
               ( names( *this ).size() != detsets( *this ).size() ) ) ) {
            std::println( std::cerr, "<xAOD::EventInfo_v1::streamTags> ERROR "
                          "Corrupt information found!" );
            std::println( std::cerr, "  streamTagNames          = {}", names( *this ) );
            std::println( std::cerr, "  streamTagTypes          = {}", types( *this ) );
            std::println( std::cerr, "  streamTagObeysLumiblock = {}", olb( *this ) );
            std::print( std::cerr, "  streamTagRobs           = " );
            if( robsets.isAvailable( *this ) ) {
               std::println( std::cerr, "N/A" );
            } else {
               std::println( std::cerr, "{}", robsets( *this ) );
            }
            std::print( std::cerr, "  streamTagDets           = " );
            if( detsets.isAvailable( *this ) ) {
               std::println( std::cerr, "N/A" );
            } else {
               std::println( std::cerr, "{}", detsets( *this ) );
            }
         }
 
         else {
           // Fill the tags.
           for( size_t i = 0; i < names( *this ).size(); ++i ) {
             static const std::set< uint32_t > dummySet;
             tags.emplace_back( names( *this )[ i ],
                                types( *this )[ i ],
                                olb( *this )[ i ],
                                ( robsets.isAvailable( *this ) ?
                                  robsets( *this )[ i ] :
                                  dummySet ),
                                ( detsets.isAvailable( *this ) ?
                                  detsets( *this )[ i ] :
                                  dummySet ) );
           }
         }
 
         // Set the cache.
         m_streamTags.set (std::move (tags));
      }
 
      // Return the cached object:
      return *m_streamTags.ptr();
   }
 
   void EventInfo_v1::setStreamTags( const std::vector< StreamTag >& value ) {
 
      // Update the cached information:
      m_streamTags.store (value);
 
      // Clear the persistent information:
      names( *this ).clear(); types( *this ).clear(); olb( *this ).clear();
      robsets( *this ).clear(); detsets( *this ).clear();
 
      // Fill the persistent information:
      std::vector< StreamTag >::const_iterator itr = value.begin();
      std::vector< StreamTag >::const_iterator end = value.end();
      for( ; itr != end; ++itr ) {
         names( *this ).push_back( itr->name() );
         types( *this ).push_back( itr->type() );
         olb( *this ).push_back( itr->obeysLumiblock() );
         robsets( *this ).push_back( itr->robs() );
         detsets( *this ).push_back( itr->dets() );
      }
 
      return;
   }
 
   //

   //
   //          Implementation of the pileup information functions
   //

   static const SG::Accessor< float >
      accActualInteractionsPerCrossing( "actualInteractionsPerCrossing" );
   static const SG::Accessor< float >
      accAverageInteractionsPerCrossing( "averageInteractionsPerCrossing" );
 
   float EventInfo_v1::actualInteractionsPerCrossing() const {
 
      // If the value is not available, then return 0.0, but allow users to
      // find out about this issue.
      if( ! accActualInteractionsPerCrossing.isAvailable( *this ) ) {
         xAODEventInfoPrivate::pileupUnsetHook();
         return 0.0f;
      }
      return accActualInteractionsPerCrossing( *this );
   }
 
   void EventInfo_v1::setActualInteractionsPerCrossing( float value ) {
 
      accActualInteractionsPerCrossing( *this ) = value;
      return;
   }
 
   float EventInfo_v1::averageInteractionsPerCrossing() const {
 
      // If the value is not available, then return 0.0, but allow users to
      // find out about this issue.
      if( ! accAverageInteractionsPerCrossing.isAvailable( *this ) ) {
         xAODEventInfoPrivate::pileupUnsetHook();
         return 0.0f;
      }
      return accAverageInteractionsPerCrossing( *this );
   }
 
   void EventInfo_v1::setAverageInteractionsPerCrossing( float value ) {
 
      accAverageInteractionsPerCrossing( *this ) = value;
      return;
   }
 
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint64_t,
                                         pileUpMixtureIDLowBits,
                                         setPileUpMixtureIDLowBits )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint64_t,
                                         pileUpMixtureIDHighBits,
                                         setPileUpMixtureIDHighBits )
 
   EventInfo_v1::PileUpMixtureID EventInfo_v1::pileUpMixtureID() const {
 
      PileUpMixtureID id{};
 
      // We need to check if the values are actually stored
      if ( xAODEventInfoPrivate::accLow.isAvailable( *this )
             && xAODEventInfoPrivate::accHigh.isAvailable( *this ) ) {
         id.lowBits = pileUpMixtureIDLowBits();
         id.highBits = pileUpMixtureIDHighBits();
      }
 
      return id;
 
   }
 
   void EventInfo_v1::setPileUpMixtureID( const PileUpMixtureID& value ) {
 
      setPileUpMixtureIDLowBits( value.lowBits );
      setPileUpMixtureIDHighBits( value.highBits );
 
   }
 
   EventInfo_v1::SubEvent::
   SubEvent( int16_t time, uint16_t index, PileUpType type,
             const ElementLink< EventInfoContainer_v1 >& link )
      : m_time( time ), m_index( index ), m_type( type ), m_link( link ) {
 
   }
 
   int16_t EventInfo_v1::SubEvent::time() const {
 
      return m_time;
   }
 
   uint16_t EventInfo_v1::SubEvent::index() const {
 
      return m_index;
   }
 
   EventInfo_v1::PileUpType EventInfo_v1::SubEvent::type() const {
 
      return m_type;
   }
 
   const std::string& EventInfo_v1::SubEvent::typeName() const {
 
      // This is a really inefficienct implementation, but didn't
      // feel like writing a short and efficient implementation for C++11,
      // and a longer but still efficient version for C++03. This is a
      // medium-sized, slow implementation that works everywhere... :-P
      if( m_type == Signal ) {
         static const std::string name = "Signal";
         return name;
      } else if( m_type == MinimumBias ) {
         static const std::string name = "MinimumBias";
         return name;
      } else if( m_type == Cavern ) {
         static const std::string name = "Cavern";
         return name;
      } else if( m_type == HaloGas ) {
         static const std::string name = "HaloGas";
         return name;
      } else if( m_type == HighPtMinimumBias ) {
         static const std::string name = "HighPtMinimumBias";
         return name;
      } else if( m_type == ZeroBias ) {
         static const std::string name = "ZeroBias";
         return name;
      } else {
         static const std::string name = "Unknown";
         return name;
      }
   }
 
   const ElementLink< EventInfoContainer_v1 >&
   EventInfo_v1::SubEvent::link() const {
 
      return m_link;
   }
 
   const EventInfo_v1* EventInfo_v1::SubEvent::ptr() const {
 
      if( m_link.isValid() ) {
         return *m_link;
      } else {
         return nullptr;
      }
   }
 
   //
   // Accessor objects for the sub-event properties:
   //
   static const SG::Accessor< std::vector< int16_t > >
      timeAcc( "subEventTime" );
   static const SG::Accessor< std::vector< uint16_t > >
      indexAcc( "subEventIndex" );
   static const SG::Accessor< std::vector< ElementLink< EventInfoContainer_v1 > > >
      linkAcc( "subEventLink" );
   static const SG::Accessor< std::vector< uint16_t > >
      typeAcc( "subEventType" );
 
   std::vector< EventInfo_v1::SubEvent >
   EventInfo_v1::makeSubEvents() const
   {
     std::vector< SubEvent > subEvents;
 
     // Check if any of the information is available:
     if( ( ! timeAcc.isAvailable( *this ) ) &&
         ( ! indexAcc.isAvailable( *this ) ) &&
         ( ! linkAcc.isAvailable( *this ) ) &&
         ( ! typeAcc.isAvailable( *this ) ) )
     {
       // If not, return right away:
       return subEvents;
     }
     // A little sanity check:
     size_t size = 0;
     if( timeAcc.isAvailable( *this ) ) {
       size = timeAcc( *this ).size();
     } else if( indexAcc.isAvailable( *this ) ) {
       size = indexAcc( *this ).size();
     } else if( linkAcc.isAvailable( *this ) ) {
       size = linkAcc( *this ).size();
     } else if( typeAcc.isAvailable( *this ) ) {
       size = typeAcc( *this ).size();
     } else {
       std::println( std::cerr, "xAOD::EventInfo_v1 ERROR Logic error in subEvents()" );
       return subEvents;
     }
     if( ( timeAcc.isAvailable( *this ) &&
           ( size != timeAcc( *this ).size() ) ) ||
         ( indexAcc.isAvailable( *this ) &&
           ( size != indexAcc( *this ).size() ) ) ||
         ( linkAcc.isAvailable( *this ) &&
           ( size != linkAcc( *this ).size() ) ) ||
         ( typeAcc.isAvailable( *this ) &&
           ( size != typeAcc( *this ).size() ) ) ) {
       std::println( std::cerr, "xAOD::EventInfo_v1 ERROR Data corruption found in "
                     "the sub-event information" );
       std::println( std::cerr, "subEventTime  = {}",
                     ( timeAcc.isAvailable( *this ) ? timeAcc( *this ) :
                       std::vector< int16_t >() ) );
       std::println( std::cerr, "subEventIndex  = {}",
                     ( indexAcc.isAvailable( *this ) ? indexAcc( *this ) :
                       std::vector< uint16_t >() ) );
 
       auto format_el = [] (const ElementLink< EventInfoContainer_v1 >& el)
       {
         return std::format ("{}:{}", el.dataID(), el.index());
       };
       const std::vector< ElementLink< EventInfoContainer_v1 > >& links =
         linkAcc.isAvailable( *this ) ? linkAcc( *this ) :
         std::vector< ElementLink< EventInfoContainer_v1 > >();
       auto linksform = links | std::views::transform (format_el);
 
       std::println( std::cerr, "subEventLink = {}", linksform );
       std::println( std::cerr,"subEventType  = {}",
                     ( typeAcc.isAvailable( *this ) ? typeAcc( *this ) :
                       std::vector< uint16_t >() ) );
       return subEvents;
     }
     // Fill up the cache:
     for( size_t i = 0; i < size; ++i ) {
       const int16_t time =
         timeAcc.isAvailable( *this ) ? timeAcc( *this )[ i ] : 0;
       const uint16_t index =
         indexAcc.isAvailable( *this ) ? indexAcc( *this )[ i ] : 0;
       const ElementLink< EventInfoContainer_v1 > link =
         linkAcc.isAvailable( *this ) ? linkAcc( *this )[ i ] :
         ElementLink< EventInfoContainer_v1 >();
       const PileUpType type =
         ( typeAcc.isAvailable( *this ) ?
           static_cast< PileUpType >( typeAcc( *this )[ i ] ) :
           Unknown );
       subEvents.emplace_back( time, index, type, link );
     }
 
     return subEvents;
   }
 
   const std::vector< EventInfo_v1::SubEvent >&
   EventInfo_v1::subEvents() const {
 
      // Cache the new information if necessary:
      if( !m_subEvents.isValid() ) {
        m_subEvents.set (makeSubEvents());
      }
 
      // Return the cached vector:
      return *m_subEvents.ptr();
   }
 
   void EventInfo_v1::setSubEvents( const std::vector< SubEvent >& value ) {
 
      // Update the cached information:
      m_subEvents.store (value);
 
      // Clear the persistent information:
      timeAcc( *this ).clear(); indexAcc( *this ).clear();
      typeAcc( *this ).clear(); linkAcc( *this ).clear();
 
      // Fill the persistent information:
      std::vector< SubEvent >::const_iterator itr = value.begin();
      std::vector< SubEvent >::const_iterator end = value.end();
      for( ; itr != end; ++itr ) {
         timeAcc( *this ).push_back( itr->time() );
         indexAcc( *this ).push_back( itr->index() );
         typeAcc( *this ).push_back( static_cast< uint16_t >( itr->type() ) );
         linkAcc( *this ).push_back( itr->link() );
      }
 
      return;
   }
 
   void EventInfo_v1::addSubEvent( const SubEvent& subEvent ) {
 
      // First, make sure that the persistent and transient variables are in
      // sync:
      subEvents();
 
      // Now, add the new sub-event:
      std::vector<SubEvent> subEvents = *m_subEvents.ptr();
      subEvents.push_back( subEvent );
      m_subEvents.store (std::move (subEvents));
      timeAcc( *this ).push_back( subEvent.time() );
      indexAcc( *this ).push_back( subEvent.index() );
      typeAcc( *this ).push_back( static_cast< uint16_t >( subEvent.type() ) );
      linkAcc( *this ).push_back( subEvent.link() );
 
      return;
   }
 
   void EventInfo_v1::clearSubEvents() {
 
      // Clear both the transient and persistent variables:
      m_subEvents.store (std::vector<SubEvent>());
      m_subEvents.reset();
      timeAcc( *this ).clear(); indexAcc( *this ).clear();
      typeAcc( *this ).clear(); linkAcc( *this ).clear();
 
      return;
   }
 
   const std::string& EventInfo_v1::PileUpType2Name(PileUpType typ)
   {
      static const std::string typNam[PileUp_NTYPES+1] = {
         "Unknown" /*99*/,
         "Signal" /*0*/,
         "MinimumBias" /*1*/,
         "Cavern" /*2*/,
         "HaloGas"/*3*/,
         "ZeroBias"/*4*/ };
      int  t = (typ==Unknown)? 0: (int)typ+1;
      assert( t <= PileUp_NTYPES );
      return typNam[t];
   }
 
   EventInfo_v1::PileUpType EventInfo_v1::PileUpInt2Type(unsigned short typ)
   {
      static const PileUpType typEnum[PileUp_NTYPES+1] = {
         Unknown /*99*/, Signal /*0*/, MinimumBias /*1*/, Cavern /*2*/, HaloGas /*3*/, ZeroBias /*4*/
      };
      int t = (typ==99)? 0: (int)typ+1;
      assert( t <= PileUp_NTYPES );
      return typEnum[t];
   }
 
   //

   //
   //                    Implementation of the detector flags
   //

   static const uint32_t EF_BITS        = 0x0FFFFFFF;
   static const uint32_t EF_ERROR_BITS  = 0xF0000000;
   static const uint32_t EF_ERROR_SHIFT = 28;
 
   uint32_t EventInfo_v1::eventFlags( EventFlagSubDet subDet ) const {
 
      return ( ( *eventFlagsConstAccessorsV1( subDet ) )( *this ) &
               EF_BITS );
   }
 
   bool EventInfo_v1::isEventFlagBitSet( EventFlagSubDet subDet,
                                         size_t bit ) const {
 
      // A little sanity check:
      if( bit >= EF_ERROR_SHIFT ) {
         throw std::runtime_error( "EventInfo_v1::isEventFlagBitSet: Asked for "
                                   "non-existent bit" );
      }
 
      // Get the value of the flags:
      uint32_t value = ( *eventFlagsConstAccessorsV1( subDet ) )( *this );
 
      // Dig out the bit we are asking for:
      return ( ( value >> bit ) & 0x1 );
   }
 
   bool EventInfo_v1::setEventFlags( EventFlagSubDet subDet, uint32_t flags ) {
 
      // Get the accessor:
      const SG::AtomicDecorator< uint32_t >* acc = eventFlagsAccessorsV1( subDet );
      if( ! acc ) {
         return false;
      }
 
      // Construct the value that we want to store, taking the current error
      // flags into account:
      std::atomic<uint32_t>& a = (*acc)(*this);
      uint32_t orig = a;
      uint32_t value = ( ( orig & EF_ERROR_BITS ) | ( flags & EF_BITS ) );
      while (!a.compare_exchange_strong (orig, value)) {
        CxxUtils::stall();
        value = ( ( orig & EF_ERROR_BITS ) | ( flags & EF_BITS ) );
      }
 
      // Tell the user that we were successful:
      return true;
   }
 
   bool EventInfo_v1::setEventFlagBit( EventFlagSubDet subDet, size_t bit) const
   {
     return updateEventFlagBit (subDet, bit);
   }
 
   bool EventInfo_v1::updateEventFlagBit( EventFlagSubDet subDet, size_t bit) const
   {
      // Check if the bit makes sense:
      if( bit >= EF_ERROR_SHIFT ) {
         return false;
      }
 
      // Don't try to write if the requested flag is already set.
      uint32_t existingFlags = (*eventFlagsConstAccessorsV1( subDet ))( *this );
      if (existingFlags & (1u << bit)) {
        return true;
      }
 
      // Get the accessor:
      const SG::AtomicDecorator< uint32_t >* acc = eventFlagsAccessorsV1( subDet );
      if( ! acc ) {
         return false;
      }
 
      // Set the new value:
      ( *acc )( *this ) |= ( 1u << bit );
 
      // Tell the user that we were successful:
      return true;
   }
 
   bool EventInfo_v1::resetEventFlagBit( EventFlagSubDet subDet, size_t bit)
   {
      // Get the accessor:
      const SG::AtomicDecorator< uint32_t >* acc = eventFlagsAccessorsV1( subDet );
      if( ! acc ) {
         return false;
      }
 
      // Check if the bit makes sense:
      if( bit >= EF_ERROR_SHIFT ) {
         return false;
      }
 
      // Set the new value:
      ( *acc )( *this ) &= ~( 1u << bit );
 
      // Tell the user that we were successful:
      return true;
   }
 
   bool EventInfo_v1::updateEventFlags( const EventFlagSubDet subDet,
                                        const uint32_t flags_in) const
   {
      uint32_t flags = flags_in & EF_BITS;
 
      // Don't try to write if all requested flags are already set.
      uint32_t existingFlags = (*eventFlagsConstAccessorsV1( subDet ))( *this );
      if ((existingFlags | flags) ==  existingFlags) {
        return true;
      }
 
      // Get the accessor:
      const SG::AtomicDecorator< uint32_t >* acc = eventFlagsAccessorsV1( subDet );
      if( ! acc ) {
         return false;
      }
 
      // Set the new value:
      ( *acc )( *this ) |= ( flags & EF_BITS );
 
      // Tell the user that we were successful:
      return true;
   }
 
   EventInfo_v1::EventFlagErrorState
   EventInfo_v1::errorState( EventFlagSubDet subDet ) const {
 
      // Get the value in one go:
      return static_cast< EventFlagErrorState >(
         ( ( *eventFlagsConstAccessorsV1( subDet ) )( *this ) >> EF_ERROR_SHIFT ) &
         0xF );
   }
 
   bool EventInfo_v1::setErrorState( EventFlagSubDet subDet,
                                     EventFlagErrorState state ) {
 
      // Get the accessor:
      const SG::AtomicDecorator< uint32_t >* acc = eventFlagsAccessorsV1( subDet );
      if( ! acc ) {
         return false;
      }
 
      // Check its value:
      if( ( state != NotSet ) && ( state != Warning ) && ( state != Error ) ) {
         return false;
      }
 
      // Construct the new value:
      std::atomic<uint32_t>& a = (*acc)(*this);
      uint32_t orig = a;
      uint32_t value = ( ( orig & EF_BITS ) |
                         ( static_cast< uint32_t >( state ) <<
                           EF_ERROR_SHIFT ) );
      while (!a.compare_exchange_strong (orig, value)) {
        CxxUtils::stall();
        value = ( ( orig & EF_BITS ) |
                  ( static_cast< uint32_t >( state ) <<
                    EF_ERROR_SHIFT ) );
      }
 
      // Tell the user that we were successful:
      return true;
   }
 
   bool EventInfo_v1::updateErrorState( const EventFlagSubDet subDet,
                                        const EventFlagErrorState state ) const
   {
      // Check its value:
      if( ( state != NotSet ) && ( state != Warning ) && ( state != Error ) ) {
         return false;
      }
 
      // Return without trying to write if the desired state is
      // already set.
      if (errorState (subDet) == state) {
        return true;
      }
 
      // Get the accessor:
      const SG::AtomicDecorator< uint32_t >* acc = eventFlagsAccessorsV1( subDet );
      if( ! acc ) {
         return false;
      }
 
      // Construct the new value:
      std::atomic<uint32_t>& a = (*acc)(*this);
      uint32_t orig = a;
 
      // Only allow increasing the error state in an update.
      if (state < ((orig >> EF_ERROR_SHIFT) & 0xf)) {
        return false;
      }
 
      uint32_t value = ( ( orig & EF_BITS ) |
                         ( static_cast< uint32_t >( state ) <<
                           EF_ERROR_SHIFT ) );
      while (!a.compare_exchange_strong (orig, value)) {
        if (state < ((orig >> EF_ERROR_SHIFT) & 0xf)) {
          return false;
        }
 
        value = ( ( orig & EF_BITS ) |
                  ( static_cast< uint32_t >( state ) <<
                    EF_ERROR_SHIFT ) );
 
        CxxUtils::stall();
      }
 
      // Tell the user that we were successful:
      return true;
   }
 
   //

   //
   //                Implementation of the beam spot functions
   //
 
   AUXSTORE_PRIMITIVE_GETTER( EventInfo_v1, float, beamPosX )
   AUXSTORE_PRIMITIVE_GETTER( EventInfo_v1, float, beamPosY )
   AUXSTORE_PRIMITIVE_GETTER( EventInfo_v1, float, beamPosZ )
 
   void EventInfo_v1::setBeamPos( float x, float y, float z ) {
 
      // The accessor objects:
      static const Accessor< float > accX( "beamPosX" );
      static const Accessor< float > accY( "beamPosY" );
      static const Accessor< float > accZ( "beamPosZ" );
 
      // Set the variables:
      accX( *this ) = x;
      accY( *this ) = y;
      accZ( *this ) = z;
 
      return;
   }
 
   AUXSTORE_PRIMITIVE_GETTER( EventInfo_v1, float, beamPosSigmaX )
   AUXSTORE_PRIMITIVE_GETTER( EventInfo_v1, float, beamPosSigmaY )
   AUXSTORE_PRIMITIVE_GETTER( EventInfo_v1, float, beamPosSigmaZ )
 
   void EventInfo_v1::setBeamPosSigma( float x, float y, float z ) {
 
      // The accessor objects:
      static const Accessor< float > accX( "beamPosSigmaX" );
      static const Accessor< float > accY( "beamPosSigmaY" );
      static const Accessor< float > accZ( "beamPosSigmaZ" );
 
      // Set the variables:
      accX( *this ) = x;
      accY( *this ) = y;
      accZ( *this ) = z;
 
      return;
   }
 
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, float, beamPosSigmaXY,
                                         setBeamPosSigmaXY )
 
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, float, beamTiltXZ,
                                         setBeamTiltXZ )
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, float, beamTiltYZ,
                                         setBeamTiltYZ )
 
   AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( EventInfo_v1, uint32_t, beamStatus,
                                         setBeamStatus )
 

   static const SG::Accessor< float >
      accBeamSpotWeight( "beamSpotWeight" );
 
   bool EventInfo_v1::hasBeamSpotWeight() const {
      return accBeamSpotWeight.isAvailable( *this );
   }
 
   float EventInfo_v1::beamSpotWeight() const {
      // If the value is not available, then return 1.0
      if( ! hasBeamSpotWeight() ) return 1.0f;
      return accBeamSpotWeight( *this );
   }
 
   void EventInfo_v1::setBeamSpotWeight( float value ) {
      accBeamSpotWeight( *this ) = value;
      return;
   }
 
 
   //
 
   StoreGateSvc* EventInfo_v1::evtStore() const {
 
      return m_evtStore;
   }
 
   void EventInfo_v1::setEvtStore( StoreGateSvc* svc ) {
 
      m_evtStore = svc;
      return;
   }
 
   void EventInfo_v1::toPersistent() {
 
      // Check if the ElementLink variable is available, and writable:
      if( linkAcc.isAvailableWritable( *this ) ) {
         // Prepare the ElementLink objects for ROOT I/O:
         std::vector< ElementLink< EventInfoContainer_v1 > >::iterator
            el_itr = linkAcc( *this ).begin();
         std::vector< ElementLink< EventInfoContainer_v1 > >::iterator
            el_end = linkAcc( *this ).end();
         for( ; el_itr != el_end; ++el_itr ) {
            el_itr->toPersistent();
         }
      }
 
      return;
   }

   void EventInfo_v1::toTransient() {
 
      m_streamTags.reset();
      m_subEvents.reset();
#ifdef XAOD_STANDALONE
      m_evtStore = nullptr;
#else
      m_evtStore = dynamic_cast<StoreGateSvc*> (Atlas::proxyDictFromEventContext());
#endif
 
      if( usingStandaloneStore() ) {
         setStore( ( SG::IAuxStore* ) nullptr );
      }
 
      return;
   }
 
   std::string EventInfo_v1::toString() const {
      return std::format(
         "[Run,Evt,Lumi,Time,BunchCross,DetMask] = [{},{},{},{}:{},{},{:#018x}]",
         runNumber(),
         eventNumber(),
         lumiBlock(),
         timeStamp(),
         timeStampNSOffset(),
         bcid(),
         detectorMask() );
   }

   std::ostream& operator<< ( std::ostream& out,
                              const xAOD::EventInfo_v1& ei ) {
     std::print( out, "{}", ei.toString() );
     return out;
   }

   std::ostream& operator<<( std::ostream &out,
                             const xAOD::EventInfo_v1::PileUpMixtureID& id ) {
       std::print( out, "{}", id );
       return out;
   }

   bool operator== ( const xAOD::EventInfo_v1::PileUpMixtureID& a,
                     const xAOD::EventInfo_v1::PileUpMixtureID& b ) {
 
       return a.lowBits == b.lowBits && a.highBits == b.highBits;
 
   }
 
} // namespace xAOD