MultipleEventLoopMgr.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include <string>
#include <vector>
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/TypeNameString.h"
#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/IAlgTool.h"
#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartIF.h"
#include "AthenaKernel/INextPassFilter.h"
#include "MultipleEventLoopMgr.h"
 
using std::string;
using std::vector;
 
MultipleEventLoopMgr::MultipleEventLoopMgr(const std::string& nam, 
                       ISvcLocator* svcLoc) :
  AthenaEventLoopMgr(nam, svcLoc),
  m_pToolSvc( "ToolSvc", nam ), 
  m_pAlgMgr(nullptr), m_passDone(0) 
{
  declareProperty("NextPassFilter", m_nextPassFilterName);
  declareProperty("ToBeReinitialized", m_toBeReInitializedNames);
}
 
MultipleEventLoopMgr::~MultipleEventLoopMgr() {
  if (m_pAlgMgr) m_pAlgMgr->release();
}
 
IAlgManager* 
MultipleEventLoopMgr::algMgr() {
  if ( nullptr == m_pAlgMgr ) {
    SmartIF<IAlgManager> algMan(serviceLocator());
    if( algMan.isValid() ) m_pAlgMgr=&*algMan;
    else throw GaudiException("IAlgManager not found", name(), StatusCode::FAILURE);
    m_pAlgMgr->addRef();
  }
  return m_pAlgMgr;
}
 
INextPassFilter* 
MultipleEventLoopMgr::nextPassFilter() {
  INextPassFilter* pFilter(nullptr); 
  const string& filterName(m_nextPassFilterName.value());
  if (!(filterName.empty())) {
    Gaudi::Utils::TypeNameString theFilter(filterName);
    IAlgTool* pHoldTool(nullptr);
    if ( (m_pToolSvc->retrieveTool(theFilter.type(), theFilter.name(), 
                   pHoldTool)).isSuccess() ) { 
      pFilter=dynamic_cast<INextPassFilter*>(pHoldTool);
    }
 
    SmartIF<IAlgorithm>& pHoldAlg = algMgr()->algorithm(theFilter, /*createIf*/false);
    if (nullptr == pFilter && pHoldAlg) {
      pFilter=dynamic_cast<INextPassFilter*>(pHoldAlg.get());
    }
  }
  if (nullptr == pFilter) {
    Gaudi::Utils::TypeNameString theFilter(filterName);
    ATH_MSG_WARNING( "Could not locate filter {}/{}",
                     theFilter.type(), theFilter.name());
  }
  return pFilter;
}
bool
MultipleEventLoopMgr::doNextPass() {
  INextPassFilter* pFilter(nextPassFilter());
  //if no tool found or tool not an INextPassFilter we return false
  //and terminate the multiple pass iteration
  return ( nullptr != pFilter && pFilter->doNextPass() );
}
StatusCode
MultipleEventLoopMgr::reInitList() {
  StatusCode sc;
  for (const std::string& name : m_toBeReInitializedNames.value()) {
    SmartIF<IService>& svc = serviceLocator()->service(name, /*createIf*/false);
    if (svc) sc = svc->reinitialize();
    if (!sc.isSuccess()) return sc;
  }
  return sc;
}
 
StatusCode 
MultipleEventLoopMgr::nextEvent(int maxevt) {
  StatusCode sc;
  do {
    ATH_MSG_INFO( "nextEvent: starting pass #{}", m_passDone );
    // Reset run number to assure BeginRun each rewind
    m_currentRun = 0;
    sc = AthenaEventLoopMgr::nextEvent(maxevt);
    ATH_MSG_INFO( "nextEvent: finished pass #{}", m_passDone);
    m_passDone++;
  } while ( sc.isSuccess() &&                    //pass ok
        doNextPass() &&                      //another one?
        (sc = reInitList()).isSuccess() &&   //then reinit svcs
        (sc = seek(0)).isSuccess() );        //and rewind selector
  return sc;
}