PileUpMergeSvc Class Reference

the preferred mechanism to access information from the different event stores in a pileup job. More...

#include <PileUpMergeSvc.h>

Inheritance diagram for PileUpMergeSvc:

Collaboration diagram for PileUpMergeSvc:

Classes
struct	TimedList
	generate the types of the timed data objects More...
class	Range
	the active crossing range for a data object (CLID/key combination) More...

Public Member Functions
	PileUpMergeSvc (const std::string &name, ISvcLocator *svc)
	Standard Gaudi Constructor.
virtual	~PileUpMergeSvc ()
virtual StatusCode	initialize () override
	Service initialisation.
template<typename KEY, typename DATA>
StatusCode	retrieveOriginal (const KEY &dataKey, const DATA *&data)
	retrieve keyed DATA objs for the original event only
template<typename KEY, typename DATA>
StatusCode	retrieveSingleSubEvtData (const KEY &dataKey, const DATA *&data, int bunchXing, SubEventIterator iEvt)
template<typename KEY, typename TIMEDDATA>
StatusCode	retrieveSubEvtsData (const KEY &dataKey, TIMEDDATA &timedData)
	retrieve keyed DATA objs for all sub-events and attach a time to them
template<typename KEY, typename TIMEDDATA>
StatusCode	retrieveSubSetEvtData (const KEY &dataKey, TIMEDDATA &timedData, int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents)
template<typename KEY, typename TIMEDDATA>
StatusCode	retrieveSubEvtsData (const KEY &dataKey, TIMEDDATA &timedData, unsigned int &numberOfSimHits)
	retrieve keyed DATA objs for all sub-events and attach a time to them
StatusCode	clearDataCaches ()
	clear bkg event caches from unneeded data objects (as configured using PileUpXingFolder CacheRefreshFrequency property)
const xAOD::EventInfo *	getPileUpEvent (StoreGateSvc *sg, const std::string &einame)
	get EventInfo from SG, by default using p_overStore
const xAOD::EventInfo *	getPileUpEvent (const EventContext &ctx, const std::string &einame)
	get EventInfo from SG given by ctx
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Private Types
typedef std::map< std::pair< CLID, std::string >, Range >	RangeContainer

Private Member Functions
template<typename DATA, typename KEY>
bool	isLive (const KEY &key, int iXing)
	is iXing live for DATA/key?
bool	isLive (CLID id, const std::string &dataKey, int iXing)
void	decodeIntervals ()
	setup PileUpIntervals
bool	doRefresh (const Range &r, int iXing)

Private Attributes
ServiceHandle< StoreGateSvc >	p_overStore
	overlaid SG (default)
ToolHandleArray< IPileUpXingFolder >	m_intervals
SG::SlotSpecificObj< std::mutex > m_slotMutex	ATLAS_THREAD_SAFE
RangeContainer	m_ranges
ToolHandle< ITriggerTime >	m_pITriggerTime
	controls PileUpTimedEventIndex for TimedData returned by retrieveSubEvts
BooleanProperty	m_returnTimedData
StringProperty	m_EventInfoKeyName
ToolHandle< xAODMaker::IEventInfoCnvTool >	m_xAODCnvTool
	property: Handle to the EventInfo -> xAOD::EventInfo converter tool

Detailed Description

the preferred mechanism to access information from the different event stores in a pileup job.

access PileUpEventInfo to locate data objects (typically hit collections) to be merged attaching sub-evt time offsets

Author

Paolo Calafiura

Definition at line 56 of file PileUpMergeSvc.h.

Member Typedef Documentation

RangeContainer

typedef std::map<std::pair<CLID, std::string>, Range> PileUpMergeSvc::RangeContainer

private

Definition at line 174 of file PileUpMergeSvc.h.

Constructor & Destructor Documentation

PileUpMergeSvc()

PileUpMergeSvc::PileUpMergeSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Standard Gaudi Constructor.

Standard Constructor.

Definition at line 39 of file PileUpMergeSvc.cxx.

  : AthService(name,svc), 
    p_overStore("StoreGateSvc", "StoreGateSvc")
{
}

~PileUpMergeSvc()

virtual PileUpMergeSvc::~PileUpMergeSvc ( )

inlinevirtual

Definition at line 62 of file PileUpMergeSvc.h.

{}

Member Function Documentation

clearDataCaches()

StatusCode PileUpMergeSvc::clearDataCaches

(

)

clear bkg event caches from unneeded data objects (as configured using PileUpXingFolder CacheRefreshFrequency property)

Definition at line 270 of file PileUpMergeSvc.cxx.

                                {
  StatusCode sc(StatusCode::FAILURE);
  const xAOD::EventInfo* pEvent;
  if (0 != (pEvent=getPileUpEvent(nullptr,m_EventInfoKeyName))) {
    // access the sub events DATA objects...
    for( const xAOD::EventInfo::SubEvent& subEv : pEvent->subEvents() ) {
      StoreGateSvc* pSubEvtSG( subEv.ptr()->evtStore() );
      assert(pSubEvtSG);
      //go object-by-object (driven by PileUpXingFolder settings)
      for (const auto& item : m_ranges) {
        SG::sgkey_t sgkey = pSubEvtSG->stringToKey (item.first.second,
                                                      item.first.first);
        SG::DataProxy* proxy = pSubEvtSG->proxy_exact (sgkey);
        //FIXME turning the double iEvt->time is fraught with peril. Luckily 
        //FIXME it just works, but we should have the beam xing in iEvt
        if (proxy && doRefresh (item.second, int(subEv.time()))) {
          proxy->setObject ((DataObject*)0);
          if (msg().level() <= MSG::DEBUG) {
            msg() << MSG::DEBUG
                  << "clearDataCachesByFolder: object with clid "
                  << item.first.first << " and key " << item.first.second
                  << " removed from cache " 
                  << pSubEvtSG->name() << endmsg;
          }
        }
      }
      //even if we don't clear the store we need to empty the trash...
      pSubEvtSG->emptyTrash();
#ifndef NDEBUG
      if (msg().level() <= MSG::VERBOSE) {
    msg() << MSG::VERBOSE
          << "clearDataCachesByFolder: done with store " << pSubEvtSG->name()
          << endmsg;
      }
#endif
    } //stores loop
    sc=StatusCode::SUCCESS;
  } //NO PILEUP EVENT?!?
  return sc;
}

decodeIntervals()

void PileUpMergeSvc::decodeIntervals ( )

private

setup PileUpIntervals

Definition at line 46 of file PileUpMergeSvc.cxx.

                                     {
  if (m_intervals.retrieve().isSuccess()) {
    ToolHandleArray<IPileUpXingFolder>::const_iterator 
      iXing(m_intervals.begin()), iEnd(m_intervals.end());
    while (iXing != iEnd) {
      const IPileUpXingFolder& xing(**iXing);
      if (msg().level() <= MSG::DEBUG) {
    msg() << MSG::DEBUG << "decodeIntervals: adding IPileUpXingFolder "
          << xing.name() << endmsg;
      }
      IPileUpXingFolder::const_iterator 
    item(xing.begin()), endItem(xing.end());
      while(item != endItem) {
    m_ranges[make_pair(item->id(), item->key())]=
      Range(xing.firstXing(), xing.lastXing(), xing.cacheRefreshFrequency());
    if (msg().level() <= MSG::VERBOSE) {
      msg() << MSG::VERBOSE 
        << "decodeInterval: accepting objects of CLID " << item->id()
        << " key " << item->key() << " in the Xing range ["
        << xing.firstXing() << ", " << xing.lastXing() << ']' 
        << " with cache refresh frequency " 
        << xing.cacheRefreshFrequency() << endmsg;
    }
    ++item;
      }
      ++iXing;
    }
  }
}

doRefresh()

bool PileUpMergeSvc::doRefresh ( const Range & r, int iXing )

private

Definition at line 262 of file PileUpMergeSvc.cxx.

                                                   {
  //  bool result(r.contains(iXing) && r.doRefresh(double(random())/RAND_MAX));
  //  std::cerr << "doRefresh: id " << id << " key " << dataKey 
  //        << " xing " << iXing << " result " << result << std::endl;
  return (r.contains(iXing) && r.doRefresh(double(random())*(1./RAND_MAX)));
}

getPileUpEvent() [1/2]

const xAOD::EventInfo * PileUpMergeSvc::getPileUpEvent	(	const EventContext &	ctx,
		const std::string &	einame )

get EventInfo from SG given by ctx

Definition at line 249 of file PileUpMergeSvc.cxx.

{
  auto* sg = dynamic_cast<StoreGateSvc*> (Atlas::proxyDictFromEventContext(ctx));
  return getPileUpEvent (sg, einame);
}

getPileUpEvent() [2/2]

const xAOD::EventInfo * PileUpMergeSvc::getPileUpEvent	(	StoreGateSvc *	sg,
		const std::string &	einame )

get EventInfo from SG, by default using p_overStore

Definition at line 112 of file PileUpMergeSvc.cxx.

{
   const EventContext& ctx = Gaudi::Hive::currentContext();
 
   if( !sg ) sg = p_overStore.get();
   const xAOD::EventInfo* xAODEventInfo = einame.empty()?
      sg->tryConstRetrieve<xAOD::EventInfo>()
      : sg->tryConstRetrieve<xAOD::EventInfo>( einame );
   if( xAODEventInfo ) {
      ATH_MSG_DEBUG("Found xAOD::EventInfo="<<xAODEventInfo<<" SG="<<sg<<" : "<<*xAODEventInfo);
      ATH_MSG_DEBUG(" EventInfo has " <<   xAODEventInfo->subEvents().size() << " subevents" );
      // recreate subevent links cache
      xAODEventInfo->subEvents();
   } else {
      // Don't allow more than one thread per slot through here.
      // Otherwise, we can get errors with multiple threads trying
      // to record the EventInfo object.
      std::lock_guard<std::mutex> lock (*m_slotMutex);
 
      // Try reading old EventInfo
      const EventInfo* pEvent = einame.empty()?
         sg->tryConstRetrieve< ::EventInfo >()
         : sg->tryConstRetrieve< ::EventInfo >( einame );
      if( pEvent ) {
         ATH_MSG_DEBUG("Converting (PileUp)EventInfo "<<pEvent<<" SG="<<sg<<" to xAOD::EventInfo");
         // Create the xAOD object(s):
         std::unique_ptr< xAOD::EventInfo >  pxAODEventInfo( new xAOD::EventInfo() );
         std::unique_ptr< xAOD::EventAuxInfo > pxAODEventAuxInfo(new xAOD::EventAuxInfo());
         pxAODEventInfo->setStore( pxAODEventAuxInfo.get() );
         pxAODEventInfo->setEvtStore( sg );
         if( !m_xAODCnvTool->convert( ctx, pEvent, pxAODEventInfo.get(), true, false ).isSuccess() ) {
            ATH_MSG_ERROR("Failed to convert  xAOD::EventInfo in SG");
            return nullptr;
         }
 
         const PileUpEventInfo* pileupEvent(dynamic_cast<const PileUpEventInfo*>(pEvent));
         if( pileupEvent ) {
            // Create an EventInfoContainer for the pileup events:
            std::unique_ptr< xAOD::EventInfoContainer > puei(new xAOD::EventInfoContainer());
            std::unique_ptr< xAOD::EventInfoAuxContainer > puaux(new xAOD::EventInfoAuxContainer());
            puei->setStore( puaux.get() );
 
            // Sub-events for the main EventInfo object:
            std::vector< xAOD::EventInfo::SubEvent > subEvents;
 
            // A map translating between the AOD and xAOD pileup event types:
            static const std::map< PileUpEventInfo::SubEvent::pileup_type,
               xAOD::EventInfo::PileUpType > pileupTypeMap = {
#define DECLARE_SE_TYPE( TYPE )                                         \
              { PileUpTimeEventIndex::TYPE, xAOD::EventInfo::TYPE },
 
               DECLARE_SE_TYPE( Unknown )
               DECLARE_SE_TYPE( Signal )
               DECLARE_SE_TYPE( MinimumBias )
               DECLARE_SE_TYPE( Cavern )
               DECLARE_SE_TYPE( HaloGas )
               DECLARE_SE_TYPE( ZeroBias )
 
#undef DECLARE_SE_TYPE
            };
 
            // A convenience type declaration:
            typedef ElementLink< xAOD::EventInfoContainer > EiLink;
 
            // Create xAOD::EventInfo objects for each pileup EventInfo object:
            auto pu_itr = pileupEvent->beginSubEvt();
            auto pu_end = pileupEvent->endSubEvt();
            const unsigned int countEvents = std::distance(pu_itr,pu_end);
            ATH_MSG_VERBOSE( "CHECKING: There are " << countEvents << " subevents in this Event." );
            for( ; pu_itr != pu_end; ++pu_itr ) {
               // Create a new xAOD::EventInfo object:
               std::unique_ptr< xAOD::EventInfo > ei( new xAOD::EventInfo() );
               // Fill it with information:
               if( ! m_xAODCnvTool->convert( ctx, pu_itr->pSubEvt, ei.get(), true, false ).isSuccess() ) {
                  ATH_MSG_ERROR("Failed to convert EventInfo to xAOD::EventInfo");
                  continue;
               }
 
               StoreGateSvc* tmpSG = pu_itr->pSubEvtSG;
               if(tmpSG) {
                  ei->setEvtStore(tmpSG);
                  ATH_MSG_VERBOSE("FOUND A STOREGATE");
               } else {
                  ATH_MSG_ERROR("FAILED TO FIND A STOREGATE");
               }
               // Store new EI into the container
               puei->push_back( ei.release() );
      
               // And now add a sub-event to the temporary list:
               auto typeItr = pileupTypeMap.find( pu_itr->type() );
               xAOD::EventInfo::PileUpType type = xAOD::EventInfo::Unknown;
               if( typeItr == pileupTypeMap.end() ) {
                  ATH_MSG_WARNING( "PileUpType not recognised: " << pu_itr->type() );
               } else {
                  type = typeItr->second;
               }
               ATH_MSG_VERBOSE("PileUpEventInfo: time = " << pu_itr->time() << ", index = " << pu_itr->index());
               subEvents.push_back( xAOD::EventInfo::SubEvent( pu_itr->time(),
                                                               pu_itr->index(),
                                                               type,
                                                               EiLink( "PileUpEventInfo", puei->size()-1, sg )));  // p_SG?
               ATH_MSG_VERBOSE("PileUpEventInfo: time = " << subEvents.back().time() << ", index = " << subEvents.back().index());
            }
 
            if( subEvents.size() ) {
               // And now update the main EventInfo object with the sub-events:
               pxAODEventInfo->setSubEvents( subEvents );
 
               // Record the xAOD object(s):
               if( !sg->record( std::move( puaux ), "PileUpEventInfoAux." ).isSuccess()
                   || !sg->record( std::move( puei ), "PileUpEventInfo" ).isSuccess() ) {  //MN: FIX - make keys configurable
                  ATH_MSG_ERROR("Failed to record xAOD::EventInfoContainer in SG");
               }
            }
         }
         // remember pointer to return the new EventInfo
         // the std::launder avoids a cppcheck warning by breaking
         // the lifetime connection between the pointer and the unique_ptr.
         xAODEventInfo = std::launder(pxAODEventInfo.get());
         // Record the xAOD object(s):
         const auto ptrVal = pxAODEventInfo.get();//for use in dbg message
         if( ! sg->record( std::move( pxAODEventAuxInfo ), "EventInfoAux." ).isSuccess() //MN: FIX? key
             || ! sg->record( std::move( pxAODEventInfo ), "EventInfo" ).isSuccess() ) {
            ATH_MSG_ERROR("Failed to record the new xAOD::EventInfo in SG");
            xAODEventInfo = nullptr;
         }
         ATH_MSG_DEBUG("Record the new xAOD::EventInfo "<<ptrVal<<" in SG="<<sg);
      }
   }
 
   if( !xAODEventInfo ) {
      ATH_MSG_DEBUG("Could not find EventInfo '" << einame << "' in store " << sg->name());
   }
   return xAODEventInfo;
}

initialize()

StatusCode PileUpMergeSvc::initialize ( )

overridevirtual

Service initialisation.

Definition at line 79 of file PileUpMergeSvc.cxx.

                              {
 
  msg() << MSG::INFO << "Initializing " << name() << ", using (xAOD::)EventInfo " << m_EventInfoKeyName << endmsg;
 
  m_autoRetrieveTools = false;
  m_checkToolDeps = false;
 
  // set up the SG service:
  if ( !(p_overStore.retrieve()).isSuccess() ) 
  {
      msg() << MSG::FATAL 
      << "Could not locate default store"
          << endmsg;
      return StatusCode::FAILURE;
  }
  if (!m_pITriggerTime.empty() && !(m_pITriggerTime.retrieve()).isSuccess() )
  {
      msg() << MSG::FATAL 
      << "Could not locate ITriggerTime tool"
          << endmsg;
      return StatusCode::FAILURE;
  }
  // Retrieve the converter tool:
  CHECK(m_xAODCnvTool.retrieve());
 
  decodeIntervals();
  
  // Initialize service:
  return StatusCode::SUCCESS;
 
}

isLive() [1/2]

bool PileUpMergeSvc::isLive ( CLID id, const std::string & dataKey, int iXing )

private

Definition at line 257 of file PileUpMergeSvc.cxx.

                                                                {
  return m_ranges[make_pair(id, dataKey)].contains(iXing);
}

isLive() [2/2]

template<typename DATA, typename KEY>

bool PileUpMergeSvc::isLive ( const KEY & key, int iXing )

private

is iXing live for DATA/key?

msg()

MsgStream & AthCommonMsg< Service >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Service >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

retrieveOriginal()

template<typename KEY, typename DATA>

StatusCode PileUpMergeSvc::retrieveOriginal	(	const KEY &	dataKey,
		const DATA *&	data )

retrieve keyed DATA objs for the original event only

retrieveSingleSubEvtData()

template<typename KEY, typename DATA>

StatusCode PileUpMergeSvc::retrieveSingleSubEvtData	(	const KEY &	dataKey,
		const DATA *&	data,
		int	bunchXing,
		SubEventIterator	iEvt )

retrieveSubEvtsData() [1/2]

template<typename KEY, typename TIMEDDATA>

StatusCode PileUpMergeSvc::retrieveSubEvtsData	(	const KEY &	dataKey,
		TIMEDDATA &	timedData )

retrieve keyed DATA objs for all sub-events and attach a time to them

retrieveSubEvtsData() [2/2]

template<typename KEY, typename TIMEDDATA>

StatusCode PileUpMergeSvc::retrieveSubEvtsData	(	const KEY &	dataKey,
		TIMEDDATA &	timedData,
		unsigned int &	numberOfSimHits )

retrieve keyed DATA objs for all sub-events and attach a time to them

retrieveSubSetEvtData()

template<typename KEY, typename TIMEDDATA>

StatusCode PileUpMergeSvc::retrieveSubSetEvtData	(	const KEY &	dataKey,
		TIMEDDATA &	timedData,
		int	bunchXing,
		SubEventIterator	bSubEvents,
		SubEventIterator	eSubEvents )

Member Data Documentation

ATLAS_THREAD_SAFE

SG::SlotSpecificObj<std::mutex> m_slotMutex PileUpMergeSvc::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 128 of file PileUpMergeSvc.h.

m_EventInfoKeyName

StringProperty PileUpMergeSvc::m_EventInfoKeyName

private

Initial value:

{this, "EventInfoKeyName", "OverlayEvent",
    "default name for EventInfo"}

Definition at line 188 of file PileUpMergeSvc.h.

                                   {this, "EventInfoKeyName", "OverlayEvent",
    "default name for EventInfo"};

m_intervals

ToolHandleArray<IPileUpXingFolder> PileUpMergeSvc::m_intervals

private

Initial value:

{this, "Intervals", {},
    "Folders specifying bunch xing intervals for different data objects"}

Definition at line 123 of file PileUpMergeSvc.h.

                                                {this, "Intervals", {},
    "Folders specifying bunch xing intervals for different data objects"};

m_pITriggerTime

ToolHandle<ITriggerTime> PileUpMergeSvc::m_pITriggerTime

private

Initial value:

{this, "TriggerTimeTool", "",
    "allows to apply a trigger time offset"}

controls PileUpTimedEventIndex for TimedData returned by retrieveSubEvts

Definition at line 177 of file PileUpMergeSvc.h.

                                          {this, "TriggerTimeTool", "",
    "allows to apply a trigger time offset"};

m_ranges

RangeContainer PileUpMergeSvc::m_ranges

private

Definition at line 175 of file PileUpMergeSvc.h.

m_returnTimedData

BooleanProperty PileUpMergeSvc::m_returnTimedData

private

Initial value:

{this, "ReturnTimedData", true,
    "determine whether the TimedData returned by retrieveSubEvts have non trivial "
    "PileUpTimeEventIndex. May be set to false for overlay with real events"}

Definition at line 181 of file PileUpMergeSvc.h.

                                   {this, "ReturnTimedData", true,
    "determine whether the TimedData returned by retrieveSubEvts have non trivial "
    "PileUpTimeEventIndex. May be set to false for overlay with real events"};

m_xAODCnvTool

ToolHandle< xAODMaker::IEventInfoCnvTool > PileUpMergeSvc::m_xAODCnvTool

private

Initial value:

{
    this, "xAODCnvTool", "xAODMaker::EventInfoCnvTool/EventInfoCnvTool"}

property: Handle to the EventInfo -> xAOD::EventInfo converter tool

Definition at line 192 of file PileUpMergeSvc.h.

                                                        {
    this, "xAODCnvTool", "xAODMaker::EventInfoCnvTool/EventInfoCnvTool"};

p_overStore

ServiceHandle<StoreGateSvc> PileUpMergeSvc::p_overStore

private

overlaid SG (default)

Definition at line 122 of file PileUpMergeSvc.h.

---

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

• PileUpMergeSvc.h
• PileUpMergeSvc.cxx