PileUpEventLoopMgr Class Reference

The ATLAS event loop for pile-up applications. More...

#include <PileUpEventLoopMgr.h>

Inheritance diagram for PileUpEventLoopMgr:

Public Member Functions
	PileUpEventLoopMgr (const std::string &nam, ISvcLocator *svcLoc)
	Standard Constructor.
virtual	~PileUpEventLoopMgr ()
	Standard Destructor.
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	nextEvent (int maxevt) override
virtual StatusCode	executeEvent (EventContext &&ctx) override
virtual StatusCode	seek (int evt) override
virtual int	curEvent () const override
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
void	modifyEventContext (EventContext &ctx, const EventID &eID, bool consume_modifier_stream)
StatusCode	setupStreams ()
	setup input and overlay selectors and iters
virtual StatusCode	executeAlgorithms (const EventContext &ctx)
	Run the algorithms for the current event.
unsigned int	getBCID (int bunchXing, unsigned int centralBCID) const
	return the 'fake BCID' corresponding to bunchXing
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
SmartIF< IAlgExecStateSvc >	m_aess
	Reference to the Algorithm Execution State Svc.
ServiceHandle< IIncidentSvc >	m_incidentSvc
	Incident Service.
PileUpStream	m_origStream
	Input Stream.
ServiceHandle< StoreGateSvc >	m_evtStore
	output store
ServiceHandle< IEvtSelector >	m_origSel
ServiceHandle< IEvtSelector >	m_signalSel
ServiceHandle< IBeamIntensity >	m_beamInt
ServiceHandle< IBeamLuminosity >	m_beamLumi
ServiceHandle< PileUpMergeSvc >	m_mergeSvc
ServiceHandle< IEvtIdModifierSvc >	m_evtIdModSvc
Gaudi::Property< unsigned int >	m_maxBunchCrossingPerOrbit
Gaudi::Property< float >	m_xingFreq
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< float >	m_maxCollPerXing
ToolHandleArray< IBkgStreamsCache >	m_caches
Gaudi::Property< bool >	m_allowSubEvtsEOF
Gaudi::Property< bool >	m_xingByXing
Gaudi::Property< int >	m_failureMode
Gaudi::Property< bool >	m_allowSerialAndMPToDiffer
Gaudi::Property< std::string >	m_evinfName
Gaudi::Property< std::string >	m_evinfContName
Gaudi::Property< uint32_t >	m_mcChannelNumber
uint32_t	m_currentRun {0}
	current run number
bool	m_firstRun {true}
int	m_nevt {0}
int	m_ncurevt {0}
bool	m_skipExecAlgs {false}
bool	m_loadProxies {true}
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

The ATLAS event loop for pile-up applications.

Definition at line 45 of file PileUpEventLoopMgr.h.

Constructor & Destructor Documentation

PileUpEventLoopMgr()

PileUpEventLoopMgr::PileUpEventLoopMgr	(	const std::string &	nam,
		ISvcLocator *	svcLoc )

Standard Constructor.

Definition at line 47 of file PileUpEventLoopMgr.cxx.

  : base_class(name, svcLoc)
  , AthMessaging (name)
  , m_incidentSvc("IncidentSvc", name)
  , m_evtStore("StoreGateSvc/StoreGateSvc", name)
{
  //  m_caches.push_back("BkgStreamsCache/MinBiasCache");
}

~PileUpEventLoopMgr()

PileUpEventLoopMgr::~PileUpEventLoopMgr ( )

virtual

Standard Destructor.

Definition at line 60 of file PileUpEventLoopMgr.cxx.

{}

Member Function Documentation

curEvent()

int PileUpEventLoopMgr::curEvent ( ) const

overridevirtual

Definition at line 515 of file PileUpEventLoopMgr.cxx.

{
  return m_nevt;
}

executeAlgorithms()

StatusCode PileUpEventLoopMgr::executeAlgorithms ( const EventContext & ctx )

privatevirtual

Run the algorithms for the current event.

Definition at line 556 of file PileUpEventLoopMgr.cxx.

{
  // Call the execute() method of all top algorithms
  for ( ListAlg::iterator ita = m_topAlgList.begin();
        ita != m_topAlgList.end();
        ++ita ) {
    StatusCode sc = (*ita)->sysExecute( ctx );
    // this duplicates what is already done in Algorithm::sysExecute, which
    // calls Algorithm::setExecuted, but eventually we plan to remove that
    // function
    m_aess->algExecState(*ita, ctx ).setState(AlgExecState::State::Done, sc);
    if ( !sc.isSuccess() ) {
      ATH_MSG_INFO ( "Execution of algorithm " <<
                     (*ita)->name() << " failed with StatusCode::" << sc );
      return sc;
    }
  }
 
  return StatusCode::SUCCESS;
}

executeEvent()

StatusCode PileUpEventLoopMgr::executeEvent ( EventContext && ctx )

overridevirtual

Fire begin-Run incident if new run:

m_failureMode 1, RECOVERABLE: skip algorithms, but do not terminate job FAILURE: terminate job

m_failureMode 2: skip algorithms, but do not terminate job

Definition at line 581 of file PileUpEventLoopMgr.cxx.

{
  if (m_firstRun || (m_currentRun != ctx.eventID().run_number())) {
    // Fire EndRun incident unless this is the first run
    if (!m_firstRun) {
      m_incidentSvc->fireIncident(Incident(this->name(),IncidentType::EndRun));
    }
    m_firstRun = false;
    m_currentRun = ctx.eventID().run_number();
 
    ATH_MSG_INFO ( "  ===>>>  start of run " << m_currentRun << "    <<<===" );
 
    // Fire BeginRun "Incident"
    m_incidentSvc->fireIncident(Incident(this->name(),IncidentType::BeginRun,ctx));
  }
 
  bool eventFailed(false);
  // Call the execute() method of all top algorithms
  StatusCode sc = executeAlgorithms( ctx );
 
  if (!sc.isSuccess()) {
    eventFailed = true;
    m_aess->setEventStatus( EventStatus::AlgFail, ctx );

    if (m_failureMode == 1 && sc.isRecoverable()) {
      ATH_MSG_WARNING ( "RECOVERABLE error returned by algorithm. " <<
                        "Skipping remaining algorithms." << std::endl <<
                        "\tNo output will be written for this event, " <<
                        "but job will continue to next event" );
      eventFailed = false;
    }

    if (m_failureMode >= 2) {
      ATH_MSG_INFO ( "Skipping remaining algorithms." << std::endl <<
                     "\tNo output will be written for this event, " <<
                     "but job will continue to next event" );
      eventFailed = false;
    }
  }
  else {
    m_aess->setEventStatus( EventStatus::Success, ctx );
 
    // Call the execute() method of all output streams
    for (ListAlg::iterator ito = m_outStreamList.begin();
           ito != m_outStreamList.end(); ++ito ) {
      sc = (*ito)->sysExecute( ctx );
      if ( !sc.isSuccess() ) {
        eventFailed = true;
      }
    }
  }
 
  //------------------------------------------------------------------------
  // Check if there was an error processing current event
  //------------------------------------------------------------------------
  return eventFailed?StatusCode::FAILURE:StatusCode::SUCCESS;
}

finalize()

StatusCode PileUpEventLoopMgr::finalize ( )

overridevirtual

Definition at line 139 of file PileUpEventLoopMgr.cxx.

{
  ATH_MSG_INFO ( "Finalizing " << this->name() );
 
  //we need to release all our BkgStreamCaches
  ToolHandleArray<IBkgStreamsCache>::iterator cacheIterator(m_caches.begin());
  ToolHandleArray<IBkgStreamsCache>::iterator endOfCaches(m_caches.end());
  while (cacheIterator != endOfCaches) {
    (*cacheIterator++)->release();
  }
  m_caches.clear();
 
  //and to clean up the store the stream owns
  CHECK(m_origStream.finalize());
 
  return MinimalEventLoopMgr::finalize();
}

getBCID()

unsigned int PileUpEventLoopMgr::getBCID ( int bunchXing, unsigned int centralBCID ) const

inlineprivate

return the 'fake BCID' corresponding to bunchXing

Definition at line 80 of file PileUpEventLoopMgr.h.

                                                                             {
    //FIXME to be completely safe this should should probably depend on the bunch spacing too. Perhaps that concept should be deprecated though?
    return static_cast<unsigned int>((((bunchXing + static_cast<int>(centralBCID)) % static_cast<int>(m_maxBunchCrossingPerOrbit)) + static_cast<int>(m_maxBunchCrossingPerOrbit) )  % static_cast<int>(m_maxBunchCrossingPerOrbit));
  }

initialize()

StatusCode PileUpEventLoopMgr::initialize ( )

overridevirtual

Definition at line 65 of file PileUpEventLoopMgr.cxx.

{
  ATH_MSG_INFO ( "Initializing " << this->name() ) ;
  if (!m_allowSerialAndMPToDiffer) {
    ATH_MSG_WARNING ( "AllowSerialAndMPToDiffer=False! This will incur serious performance penalties! But Serial and MP output will be the same." );
  }
 
  //locate the StoreGateSvc and initialize our local ptr
  CHECK(m_evtStore.retrieve());
 
  //reset output store proxy provider: we don't want to have one!
  m_evtStore->setProxyProviderSvc(nullptr);
 
  //locate the IncidentSvc and initialize our local ptr
  CHECK(m_incidentSvc.retrieve());
 
  //locate the PileUpMergeSvc and initialize our local ptr
  CHECK(m_mergeSvc.retrieve());
 
  //-------------------------------------------------------------------------
  // Setup Event Selector
  //-------------------------------------------------------------------------
  CHECK(this->setupStreams());
 
  // Get the value of SkipEvents. It is needed for seeking
  SmartIF<IProperty> prpMgr(serviceLocator());
  SmartIF<IEvtSelector> evtSelector;
  if (prpMgr.isValid()) {
    // Get event selector name. Retrieve EventSelector
    evtSelector = serviceLocator()->service(prpMgr->getProperty("EvtSel").toString());
    CHECK(evtSelector.isValid());
  }
  else {
    ATH_MSG_ERROR ( "IProperty interface not found in ApplicationMgr" );
    return StatusCode::FAILURE;
  }
 
  SmartIF<IProperty> prpMgr1(evtSelector);
  if (prpMgr1.isValid()) {
    std::string skipEventsStr = prpMgr1->getProperty("SkipEvents").toString();
    m_ncurevt = std::atoi(skipEventsStr.c_str());
  }
  else {
    ATH_MSG_ERROR ( "IProperty interface not found on the event selector" );
    return StatusCode::FAILURE;
  }
 
  // Get the AlgExecStateSvc
  m_aess = serviceLocator()->service("AlgExecStateSvc");
  if (!m_aess.isValid()) {
    ATH_MSG_FATAL ( "Error retrieving AlgExecStateSvc" );
    return StatusCode::FAILURE;
  }
 
  //--------------------------------------------------------------------------
  // Set up the EventID modifier Service
  //--------------------------------------------------------------------------
  if( m_evtIdModSvc.empty() ) {
    ATH_MSG_DEBUG ( "EventID modifier Service not set. No run number, ... overrides will be applied." );
  }
  else if ( !m_evtIdModSvc.retrieve().isSuccess() ) {
    ATH_MSG_INFO ( "Could not find EventID modifier Service. No run number, ... overrides will be applied." );
  }
 
  //-------------------------------------------------------------------------
  // Base class initialize (done at the end to allow algs to access stores)
  //-------------------------------------------------------------------------
 
  return MinimalEventLoopMgr::initialize();
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

modifyEventContext()

void PileUpEventLoopMgr::modifyEventContext ( EventContext & ctx, const EventID & eID, bool consume_modifier_stream )

private

Definition at line 169 of file PileUpEventLoopMgr.cxx.

                                                                                                               {
 
  if (m_evtIdModSvc.isSet()) {
    EventID new_eID(eID);
    // m_nevt - 1 because the PileUpEventLoopMgr increments it rather early
    m_evtIdModSvc->modify_evtid(new_eID, m_ncurevt - 1, consume_modifier_stream);
    if (msgLevel(MSG::DEBUG)) {
      unsigned int oldrunnr=eID.run_number();
      unsigned int oldLB=eID.lumi_block();
      unsigned int oldTS=eID.time_stamp();
      unsigned int oldTSno=eID.time_stamp_ns_offset();
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc runnr=" << oldrunnr << " -> " << new_eID.run_number() );
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc LB=" << oldLB << " -> " << new_eID.lumi_block() );
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc TimeStamp=" << oldTS << " -> " << new_eID.time_stamp() );
      ATH_MSG_DEBUG ( "modifyEventContext: use evtIdModSvc TimeStamp ns Offset=" << oldTSno << " -> " << new_eID.time_stamp_ns_offset() );
    }
    ctx.setEventID(new_eID);
    return;
  }
 
  ctx.setEventID( eID );
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inline

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 92 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inline

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 99 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inline

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 86 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

nextEvent()

StatusCode PileUpEventLoopMgr::nextEvent ( int maxevt )

overridevirtual

Is this correct, or should it be set to a pileup store?

ask the BeamLuminositySvc to check for a new scalefactor

Definition at line 196 of file PileUpEventLoopMgr.cxx.

{
  // make nextEvent(0) a dummy call, as needed by athenaMP
  if (0 == maxevt) {
    return StatusCode::SUCCESS;
  }
 
 
  // These following two initialization loops are performed here in case new
  // Top level Algorithms or Output Streams have been created interactively
  // at run-time instead of configuration time. Note also that it is possible
  // that some newly created Algorithms are still not initialized as a result
  // of these loops (e.g. where the membership of an existing Sequencer is
  // changed at run-time. In this case, the Algorithm::sysExecute() function
  // will ensure that the Algorithm is correctly initialized. This mechanism
  // actually makes loops redundant, but they do  provide a well defined
  // location for the initialization to take place in the non-interactive case.
 
  // Initialize the list of Algorithms. Note that existing Algorithms
  // are protected against multiple initialization attempts.
  ListAlg::iterator ita;
  for ( ita = m_topAlgList.begin(); ita != m_topAlgList.end(); ++ita ) {
    if( !((*ita)->sysInitialize()).isSuccess() ) {
      ATH_MSG_ERROR ( "Unable to initialize Algorithm: " <<
                      (*ita)->name() );
      return StatusCode::FAILURE;
    }
  }
 
  // Initialize the list of Output Streams. Note that existing Output Streams
  // are protected against multiple initialization attempts.
  for (ita = m_outStreamList.begin(); ita != m_outStreamList.end(); ++ita ) {
    if( !((*ita)->sysInitialize()).isSuccess() ) {
      ATH_MSG_ERROR ( "Unable to initialize Output Stream: " <<
                      (*ita)->name() );
      return StatusCode::FAILURE;
    }
  }
 
  const xAOD::EventInfo *inputEventInfo{};
 
  // loop over events if the maxevt (received as input) is different from -1.
  // if evtmax is -1 it means infinite loop
  while( (maxevt == -1 || m_nevt < maxevt) &&
         0 != (inputEventInfo = m_origStream.nextEventPre()) ) {
    // Check if there is a scheduled stop issued by some algorithm/sevice
    if ( m_scheduledStop ) {
      m_scheduledStop = false;
      ATH_MSG_ALWAYS ( "A stopRun was requested. Terminating event loop." );
      break;
    }
    ++m_nevt; ++m_ncurevt;
 
    //-----------------------------------------------------------------------
    // Setup overlaid event in the event store
    //-----------------------------------------------------------------------
 
    auto upOverEvent = std::make_unique<xAOD::EventInfo>();
    auto upOverEventAux = std::make_unique<xAOD::EventAuxInfo>();
    upOverEvent->setStore( upOverEventAux.get() );
    xAOD::EventInfo* pOverEvent = upOverEvent.get();
    ATH_MSG_DEBUG(" #subevents in the signal event =" << inputEventInfo->subEvents().size());
 
    // Copy the eventInfo data from origStream event
    *pOverEvent = *inputEventInfo;
    pOverEvent->clearSubEvents();  // start clean without any subevents
 
    // Need to copy this explicitly as it may be marked as a decoration.
    pOverEvent->setMCEventWeights(inputEventInfo->mcEventWeights());
 
    // Propagate MC metadata
    if (pOverEvent->mcChannelNumber() == 0) {
      if (m_mcChannelNumber.value() != 0) {
        ATH_MSG_WARNING("Input mcChannelNumber is 0, setting it to " << m_mcChannelNumber.value());
        pOverEvent->setMCChannelNumber(m_mcChannelNumber.value());
      } else {
        ATH_MSG_WARNING("Input mcChannelNumber is 0");
      }
    } else {
      if (m_mcChannelNumber.value() != 0 && pOverEvent->mcChannelNumber() != m_mcChannelNumber.value()) {
        ATH_MSG_WARNING("Input mcChannelNumber (" << pOverEvent->mcChannelNumber()
                        << ") and provided mcChannelNumber (" << m_mcChannelNumber.value() << ") do not match.");
      }
    }
 
    if (pOverEvent->mcEventNumber() == 0) {
      if (pOverEvent->eventNumber() != 0) {
        ATH_MSG_WARNING("Input mcEventNumber is 0, setting it to match the eventNumber (" << pOverEvent->eventNumber() << ")");
        pOverEvent->setMCEventNumber(pOverEvent->eventNumber());
      } else {
        ATH_MSG_ERROR("Input eventNumber and mcEventNumber are 0");
        return StatusCode::FAILURE;
      }
    }
 
    if (pOverEvent->mcEventWeights().empty()) {
      ATH_MSG_ERROR("Input mcEventWeights are empty. This should not happen.");
      return StatusCode::FAILURE;
    }
 
    // Record the xAOD object(s):
    CHECK( m_evtStore->record( std::move(upOverEventAux), m_evinfName + "Aux." ) );
    CHECK( m_evtStore->record( std::move(upOverEvent), m_evinfName ) );
    pOverEvent->setEvtStore( m_evtStore.get() );
    // Create an EventInfoContainer for the pileup events:
    xAOD::EventInfoContainer *puei(new xAOD::EventInfoContainer());
    xAOD::EventInfoAuxContainer *puaux(new xAOD::EventInfoAuxContainer());
    puei->setStore( puaux );
 
    // Record the EI container object(s):
    CHECK( m_evtStore->record( puei, m_evinfContName ) );
    CHECK( m_evtStore->record( puaux, m_evinfContName+"Aux." ) );
 
    // Setup the EventContext.
    // Ensure that the overridden run number etc. is being used
    EventContext ctx;
    EventID   ev_id = eventIDFromxAOD( pOverEvent );
    bool consume_modifier_stream = false; // FIXME/CHECK: was true inside TP converter and checks for active storegate
    // kludge FIXME
    const AthenaAttributeList* pAttrList = m_origStream.store().tryConstRetrieve<AthenaAttributeList>("Input");
    if ( pAttrList != nullptr && pAttrList->size() > 6 ) {
      // Ideally we would create the initial EventID from the TAG
      // information, but not doing that (yet?).  For now using the
      // presence of TAG information in the HITS file to indicate that
      // the EvtIdModifierSvc has not already been called for this
      // Athena event.
      consume_modifier_stream = true;
    }
    ctx.set(m_nevt,0);
    modifyEventContext(ctx, ev_id, consume_modifier_stream);
    ctx.setExtension( Atlas::ExtendedEventContext(m_evtStore->hiveProxyDict(),
                                                  ctx.eventID().run_number()) );
    Gaudi::Hive::setCurrentContext( ctx );
    m_aess->reset(ctx);
    // make copy to std::move into store
    auto puctx =std::make_unique<EventContext> ( ctx );
    if (m_evtStore->record( std::move(puctx) ,"EventContext").isFailure()) {
      ATH_MSG_ERROR ( "Error recording event context object" );
      return StatusCode::FAILURE;
    }
 
    //Update run number, event number, lumi block and timestamp from EventContext
    pOverEvent->setRunNumber( ctx.eventID().run_number() );
    pOverEvent->setEventNumber( ctx.eventID().event_number() );
    pOverEvent->setLumiBlock( ctx.eventID().lumi_block() );
    pOverEvent->setTimeStamp( ctx.eventID().time_stamp() );
    ATH_MSG_DEBUG( "Updated pOverEvent " << *pOverEvent );
 
    ATH_MSG_INFO ( "nextEvent(): overlaying original event " <<
                   pOverEvent->runNumber() << '/' <<
                   pOverEvent->eventNumber() << '/' <<
                   pOverEvent->lumiBlock() );
 
    //ask the BeamIntensitySvc to choose (and remember)
    //in which xing this event will be wrto the beam int distribution
    m_beamInt->selectT0(ctx.eventID().run_number(), ctx.eventID().event_number());
 
    // Use the position in the beam intensity array to set a BCID-like quantity
    pOverEvent->setBCID( m_beamInt->getCurrentT0BunchCrossing() );
 
    unsigned int t0BCID = pOverEvent->bcid();
    ATH_MSG_VERBOSE ( "BCID =" << t0BCID );
 
    // pOvrEt->set_user_type("Overlaid"); //FIXME    ?? MN: ?? what to do with that
 
    // Overlay RDO files should be treated like data for reco
    // purposes, so only set this for SimHit level pile-up.
    pOverEvent->setEventTypeBitmask( inputEventInfo->eventTypeBitmask() | xAOD::EventInfo::IS_SIMULATION );
 
    //  register as sub event of the overlaid
    bool addpEvent(true);
 
    ATH_MSG_DEBUG( "inputEventInfo->evtStore()="<<inputEventInfo->evtStore()<<",  pOverEvent->evtStore()=" << pOverEvent->evtStore()<<", &m_origStream.store()="<<&m_origStream.store() );
    if ( addpEvent ) {
      xAOD::EventInfo* newEv=addSubEvent(pOverEvent, inputEventInfo, 0, xAOD::EventInfo::Signal, puei, m_evinfContName );
      if(newEv->evtStore()==nullptr) newEv->setEvtStore(&m_origStream.store());
      newEv->setRunNumber( ctx.eventID().run_number() );
      newEv->setEventNumber( ctx.eventID().event_number() );
      newEv->setLumiBlock( ctx.eventID().lumi_block() );
      newEv->setTimeStamp( ctx.eventID().time_stamp() );
      ATH_MSG_DEBUG( "Added inputEventInfo="<<inputEventInfo<<" as subEvent "<<newEv<<" to pOverEvent " << pOverEvent );
      ATH_MSG_DEBUG( "  afterwards: newEv->evtStore()="<<newEv->evtStore()<<",  pOverEvent->evtStore()=" << pOverEvent->evtStore() );
      ATH_MSG_DEBUG( "  pOverEvent->subEvents()[0].ptr()="<<pOverEvent->subEvents()[0].ptr()<<" content="<<*pOverEvent->subEvents()[0].ptr()<<" store="<< pOverEvent->subEvents()[0].ptr()->evtStore() );
    }
 
    ATH_MSG_INFO ( "set aliases" );
    //add an alias to "OverlayEvent" (backward compatibility)
    CHECK(m_evtStore->setAlias(pOverEvent, "OverlayEvent"));
 
    //FIXME at this point one may want to look into the original event
    //FIXME to decide whether to skip it or to do the pile-up

    bool needupdate;
    float sf = m_beamLumi->scaleFactor( pOverEvent->runNumber(), pOverEvent->lumiBlock(), needupdate );
    float currentaveragemu(sf*m_maxCollPerXing);
    pOverEvent->setAverageInteractionsPerCrossing(currentaveragemu);
    //FIXME check whether actualInteractionsPerCrossing should be set
    //to mu for the central bunch crossing, as below, or whether it
    //should be set to the actual number of minbias piled-up in the
    //central bunch crossing for this particular event.
    pOverEvent->setActualInteractionsPerCrossing(m_beamInt->normFactor(0)*currentaveragemu);
    ATH_MSG_DEBUG ( "BCID = "<< t0BCID <<
                    ", mu =" << pOverEvent->actualInteractionsPerCrossing() <<
                    ", <mu> =" << pOverEvent->averageInteractionsPerCrossing() );
    ToolHandleArray<IBkgStreamsCache>::iterator cacheIterator(m_caches.begin());
    ToolHandleArray<IBkgStreamsCache>::iterator endOfCaches(m_caches.end());
    while (cacheIterator != endOfCaches) {
      if (needupdate) {
        (*cacheIterator)->resetEvtsPerXingScaleFactor(sf);//set cache scale factor. some caches should ignore it?
      }
      (*cacheIterator++)->newEvent(); //inform cache we overlay a new event
    }
    //-----------------------------------------------------------------------
    // loop over x-ings
    //-----------------------------------------------------------------------
    for (int iXing=m_firstXing; iXing<=m_lastXing; iXing++) {
      // if (m_xingByXing.value()) test that PileUpToolsAlg is there?
      //-----------------------------------------------------------------------
      // Read input events in bkg stores and link them to overlay store
      //-----------------------------------------------------------------------
      int t0BinCenter((int)m_xingFreq*iXing);
      unsigned int currentBCID = getBCID((t0BinCenter/25), t0BCID); //Should account for m_xingFreq>25. FIXME - hardcoded 25ns
      ATH_MSG_VERBOSE ( "Background BCID =" << currentBCID );
      cacheIterator = m_caches.begin();
      while (cacheIterator != endOfCaches) {
        // Now set the BCID for background events - also requires changes to PileUpEventInfo, SubEvent
        if (((*cacheIterator)->addSubEvts(iXing-m_firstXing, pOverEvent, t0BinCenter, m_loadProxies, currentBCID)).isFailure()) {
          //if (((*cacheIterator)->addSubEvts(iXing-m_firstXing, *pOverEvent, t0BinCenter)).isFailure()) {
          if (maxevt == -1 && m_allowSubEvtsEOF) {
            ATH_MSG_INFO ( "No more sub events for " << cacheIterator->name() );
            return StatusCode::SUCCESS;
          }
          else {
            ATH_MSG_FATAL ( "Error adding sub events to " << cacheIterator->name() );
            return StatusCode::FAILURE;
          }
        }
        ++cacheIterator;
      }
    }  //loop over xings
 
    // Calculate/copy pile-up hash
    PileUpHashHelper pileUpHashHelper;
 
    pileUpHashHelper.addToHashSource(pOverEvent);
 
    ATH_MSG_VERBOSE ( "Pile-up hash source:" << pileUpHashHelper.hashSource() );
 
    // Calculate and set hash
    uuid_t pileUpHash;
    pileUpHashHelper.calculateHash(pileUpHash);
 
    pOverEvent->setPileUpMixtureID( PileUpHashHelper::uuidToPileUpMixtureId(pileUpHash) );
 
    ATH_MSG_DEBUG("PileUpMixtureID = " << pOverEvent->pileUpMixtureID());
 
    //set active store back to the overlaid one
    m_evtStore->makeCurrent();
 
    // Execute event for all required algorithms. The overlaid event
    // (PileUpEventInfo) is considered to be current
    if (m_skipExecAlgs) {
      ATH_MSG_INFO ( "Firing reseed incident (" << pOverEvent->eventNumber() << "," << pOverEvent->runNumber() << ")" );
      m_incidentSvc->fireIncident(ContextIncident<std::pair<unsigned,unsigned> >(this->name(),"ReseedIncident",std::pair<unsigned,unsigned>(pOverEvent->eventNumber(),pOverEvent->runNumber())));
      m_incidentSvc->fireIncident(Incident(this->name(),"AfterReseedIncident"));
      ATH_MSG_INFO ( "Not going to process this event" );
    }
    else {
      if ( !(executeEvent( std::move(ctx) ).isSuccess()) ) {
        ATH_MSG_ERROR ( "Terminating event processing loop due to errors" );
        return StatusCode::FAILURE;
      }
      else {
        ATH_MSG_INFO ( "Event processing successful." );
      }
    }
    //if we are not doing overlap xing by xing clean up all stores at the end
    //the clean up is done object by object and controlled by
    //PileUpXingFolder.CacheRefreshFrequency property
    if (!m_xingByXing.value()) {
      // FIXME test that PileUpToolsAlg is NOT there?
      //clear all stores as configured in
      CHECK(m_mergeSvc->clearDataCaches());
      ATH_MSG_DEBUG ( "Cleared data caches" );
    }
    CHECK(m_evtStore->clearStore());
  }  //end of event loop
 
  if (m_skipExecAlgs) {
    m_nevt--;
  }
 
  return StatusCode::SUCCESS;
 
}

seek()

StatusCode PileUpEventLoopMgr::seek ( int evt )

overridevirtual

Definition at line 494 of file PileUpEventLoopMgr.cxx.

{
  int nevtsToAdvance = evt-m_ncurevt;
  int nParam = m_nevt+1;
  ATH_MSG_INFO ( "In PileUpEventLoopMgr::seek. m_ncurevt=" << m_ncurevt <<
                 " nevtsToAdvance=" << nevtsToAdvance );
 
  m_skipExecAlgs = true;
  for (int i=0; i<nevtsToAdvance; ++i) {
    if (m_allowSerialAndMPToDiffer) {
      m_loadProxies = (nevtsToAdvance==(i+1));
    }
    if (this->nextEvent(nParam).isFailure()) {
      ATH_MSG_ERROR ( "Seek error! Failed to advance to evt=" << m_ncurevt+1 );
      return StatusCode::FAILURE;
    }
  }
  m_skipExecAlgs = false;
  return StatusCode::SUCCESS;
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setupStreams()

StatusCode PileUpEventLoopMgr::setupStreams ( )

private

setup input and overlay selectors and iters

Definition at line 524 of file PileUpEventLoopMgr.cxx.

{
  //OK now we can run
  // retrieve selector and setup iterator (the selector has been setup as an ExtService)
  CHECK(m_origSel.retrieve());
 
  m_origStream = PileUpStream("OriginalEvent", serviceLocator(), &*m_origSel);
  if (!m_origStream.setupStore()) {
    ATH_MSG_ERROR ( "Can not setup original evt store " << m_origSel );
    return StatusCode::FAILURE;
  }
 
  //now get the bkg stream caches, and set them up
  CHECK(m_caches.retrieve());
  ATH_MSG_DEBUG ( "retrieved BkgStreamsCaches " << m_caches );
 
  ToolHandleArray<IBkgStreamsCache>::iterator cacheIterator(m_caches.begin());
  ToolHandleArray<IBkgStreamsCache>::iterator endOfCaches(m_caches.end());
  unsigned int nXings(m_lastXing-m_firstXing+1);
  unsigned int firstStore(0);
  StatusCode sc(StatusCode::SUCCESS);
  while ((cacheIterator != endOfCaches) && sc.isSuccess()) {
    sc = (*cacheIterator)->setup(m_firstXing, nXings, firstStore, &*m_beamInt);
    firstStore += (*cacheIterator)->nStores() ;
    ++cacheIterator;
  }
  return sc;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_aess

SmartIF<IAlgExecStateSvc> PileUpEventLoopMgr::m_aess

private

Reference to the Algorithm Execution State Svc.

Definition at line 69 of file PileUpEventLoopMgr.h.

m_allowSerialAndMPToDiffer

Gaudi::Property<bool> PileUpEventLoopMgr::m_allowSerialAndMPToDiffer

private

Initial value:

{this, "AllowSerialAndMPToDiffer", true,
    "When set to False, this will allow the code to reproduce serial output in an "
    "AthenaMP job, albeit with a significant performance penalty."}

Definition at line 130 of file PileUpEventLoopMgr.h.

                                                {this, "AllowSerialAndMPToDiffer", true,
    "When set to False, this will allow the code to reproduce serial output in an "
    "AthenaMP job, albeit with a significant performance penalty."};

m_allowSubEvtsEOF

Gaudi::Property<bool> PileUpEventLoopMgr::m_allowSubEvtsEOF

private

Initial value:

{this, "AllowSubEvtsEOF", true,
    "if true(default) an EOF condition in the BkgStreamsCaches is not considered "
    "to be an error IF maxevt=-1 (loop over all available events)"}

Definition at line 119 of file PileUpEventLoopMgr.h.

                                       {this, "AllowSubEvtsEOF", true,
    "if true(default) an EOF condition in the BkgStreamsCaches is not considered "
    "to be an error IF maxevt=-1 (loop over all available events)"};

m_beamInt

ServiceHandle<IBeamIntensity> PileUpEventLoopMgr::m_beamInt

private

Initial value:

{this, "BeamInt", "FlatBM",
    "The service providing the beam intensity distribution"}

Definition at line 98 of file PileUpEventLoopMgr.h.

                                         {this, "BeamInt", "FlatBM",
    "The service providing the beam intensity distribution"};

m_beamLumi

ServiceHandle<IBeamLuminosity> PileUpEventLoopMgr::m_beamLumi

private

Initial value:

{this, "BeamLuminosity", "LumiProfileSvc",
    "The service providing the beam luminosity distribution vs. run"}

Definition at line 100 of file PileUpEventLoopMgr.h.

                                           {this, "BeamLuminosity", "LumiProfileSvc",
    "The service providing the beam luminosity distribution vs. run"};

m_caches

ToolHandleArray<IBkgStreamsCache> PileUpEventLoopMgr::m_caches

private

Initial value:

{this, "bkgCaches", {},
    "list of tools managing bkg events"}

Definition at line 117 of file PileUpEventLoopMgr.h.

                                            {this, "bkgCaches", {},
    "list of tools managing bkg events"};

m_currentRun

uint32_t PileUpEventLoopMgr::m_currentRun {0}

private

current run number

Definition at line 141 of file PileUpEventLoopMgr.h.

{0};

m_evinfContName

Gaudi::Property<std::string> PileUpEventLoopMgr::m_evinfContName

private

Initial value:

{this, "EventInfoContName", c_pileUpEventInfoContName,
    "SG key for the EventInfoContainer object"}

Definition at line 135 of file PileUpEventLoopMgr.h.

                                          {this, "EventInfoContName", c_pileUpEventInfoContName,
    "SG key for the EventInfoContainer object"};

m_evinfName

Gaudi::Property<std::string> PileUpEventLoopMgr::m_evinfName

private

Initial value:

{this, "EventInfoName", c_pileUpEventInfoObjName,
    "SG key for the EventInfo object"}

Definition at line 133 of file PileUpEventLoopMgr.h.

                                      {this, "EventInfoName", c_pileUpEventInfoObjName,
    "SG key for the EventInfo object"};

m_evtIdModSvc

ServiceHandle<IEvtIdModifierSvc> PileUpEventLoopMgr::m_evtIdModSvc

private

Initial value:

{this, "EvtIdModifierSvc", "",
    "ServiceHandle for EvtIdModifierSvc"}

Definition at line 104 of file PileUpEventLoopMgr.h.

                                                {this, "EvtIdModifierSvc", "",
    "ServiceHandle for EvtIdModifierSvc"};

m_evtStore

ServiceHandle<StoreGateSvc> PileUpEventLoopMgr::m_evtStore

private

output store

Definition at line 92 of file PileUpEventLoopMgr.h.

m_failureMode

Gaudi::Property<int> PileUpEventLoopMgr::m_failureMode

private

Initial value:

{this, "FailureMode", 1,
    "Controls behaviour of event loop depending on return code of"
    " Algorithms. 0: all non-SUCCESSes terminate job. "
    "1: RECOVERABLE skips to next event, FAILURE terminates job "
    "(DEFAULT). 2: RECOVERABLE and FAILURE skip to next events"}

Definition at line 125 of file PileUpEventLoopMgr.h.

                                  {this, "FailureMode", 1,
    "Controls behaviour of event loop depending on return code of"
    " Algorithms. 0: all non-SUCCESSes terminate job. "
    "1: RECOVERABLE skips to next event, FAILURE terminates job "
    "(DEFAULT). 2: RECOVERABLE and FAILURE skip to next events"};

m_firstRun

bool PileUpEventLoopMgr::m_firstRun {true}

private

Definition at line 142 of file PileUpEventLoopMgr.h.

{true};

m_firstXing

Gaudi::Property<int> PileUpEventLoopMgr::m_firstXing

private

Initial value:

{this, "firstXing", -2,
    "time of first xing / XingFrequency (0th xing is 1st after trigger)"}

Definition at line 111 of file PileUpEventLoopMgr.h.

                                {this, "firstXing", -2,
    "time of first xing / XingFrequency (0th xing is 1st after trigger)"};

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_incidentSvc

ServiceHandle<IIncidentSvc> PileUpEventLoopMgr::m_incidentSvc

private

Incident Service.

Definition at line 86 of file PileUpEventLoopMgr.h.

m_lastXing

Gaudi::Property<int> PileUpEventLoopMgr::m_lastXing

private

Initial value:

{this, "lastXing", 1,
    "time of last xing / XingFrequency (0th xing is 1st after trigger)"}

Definition at line 113 of file PileUpEventLoopMgr.h.

                               {this, "lastXing", 1,
    "time of last xing / XingFrequency (0th xing is 1st after trigger)"};

m_loadProxies

bool PileUpEventLoopMgr::m_loadProxies {true}

private

Definition at line 147 of file PileUpEventLoopMgr.h.

{true};

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_maxBunchCrossingPerOrbit

Gaudi::Property<unsigned int> PileUpEventLoopMgr::m_maxBunchCrossingPerOrbit

private

Initial value:

{this, "MaxBunchCrossingPerOrbit", 3564,
    "The number of slots in each LHC beam. Default: 3564."}

Definition at line 107 of file PileUpEventLoopMgr.h.

                                                        {this, "MaxBunchCrossingPerOrbit", 3564,
    "The number of slots in each LHC beam. Default: 3564."};

m_maxCollPerXing

Gaudi::Property<float> PileUpEventLoopMgr::m_maxCollPerXing

private

Initial value:

{this, "MaxMinBiasCollPerXing", 23.0,
    "Set to digitization numberOfCollisions prop. for variable-mu and RunDMC jobs."}

Definition at line 115 of file PileUpEventLoopMgr.h.

                                       {this, "MaxMinBiasCollPerXing", 23.0,
    "Set to digitization numberOfCollisions prop. for variable-mu and RunDMC jobs."};

m_mcChannelNumber

Gaudi::Property<uint32_t> PileUpEventLoopMgr::m_mcChannelNumber

private

Initial value:

{ this, "MCChannelNumber", 0,
    "sample MC channel number" }

Definition at line 137 of file PileUpEventLoopMgr.h.

                                           { this, "MCChannelNumber", 0,
    "sample MC channel number" };

m_mergeSvc

ServiceHandle<PileUpMergeSvc> PileUpEventLoopMgr::m_mergeSvc

private

Initial value:

{this, "PileUpMergeSvc", "PileUpMergeSvc",
    "PileUp Merge Service"}

Definition at line 102 of file PileUpEventLoopMgr.h.

                                          {this, "PileUpMergeSvc", "PileUpMergeSvc",
    "PileUp Merge Service"};

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_ncurevt

int PileUpEventLoopMgr::m_ncurevt {0}

private

Definition at line 145 of file PileUpEventLoopMgr.h.

{0};

m_nevt

int PileUpEventLoopMgr::m_nevt {0}

private

Definition at line 144 of file PileUpEventLoopMgr.h.

{0};

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_origSel

ServiceHandle<IEvtSelector> PileUpEventLoopMgr::m_origSel

private

Initial value:

{this, "OrigSelector", "EventSelector",
    "EventSelector for original (physics) events stream"}

Definition at line 94 of file PileUpEventLoopMgr.h.

                                       {this, "OrigSelector", "EventSelector",
    "EventSelector for original (physics) events stream"};

m_origStream

PileUpStream PileUpEventLoopMgr::m_origStream

private

Input Stream.

Definition at line 89 of file PileUpEventLoopMgr.h.

m_signalSel

ServiceHandle<IEvtSelector> PileUpEventLoopMgr::m_signalSel

private

Initial value:

{this, "SignalSelector", "",
    "EventSelector for signal (hard-scatter) events stream"}

Definition at line 96 of file PileUpEventLoopMgr.h.

                                         {this, "SignalSelector", "",
    "EventSelector for signal (hard-scatter) events stream"};

m_skipExecAlgs

bool PileUpEventLoopMgr::m_skipExecAlgs {false}

private

Definition at line 146 of file PileUpEventLoopMgr.h.

{false};

m_xingByXing

Gaudi::Property<bool> PileUpEventLoopMgr::m_xingByXing

private

Initial value:

{this, "XingByXing", false,
    "if set to true we will not cache bkg events from one xing to then next. "
    "This greatly increases the amount of I/O and greatly reduces the memory required to run a job"}

Definition at line 122 of file PileUpEventLoopMgr.h.

                                  {this, "XingByXing", false,
    "if set to true we will not cache bkg events from one xing to then next. "
    "This greatly increases the amount of I/O and greatly reduces the memory required to run a job"};

m_xingFreq

Gaudi::Property<float> PileUpEventLoopMgr::m_xingFreq

private

Initial value:

{this, "XingFrequency", 25.0,
    "ns"}

Definition at line 109 of file PileUpEventLoopMgr.h.

                                 {this, "XingFrequency", 25.0,
    "ns"};

---

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

• PileUpEventLoopMgr.h
• PileUpEventLoopMgr.cxx