DoubleEventSelectorAthenaPool Class Reference

This class is the EventSelector for event data. More...

#include <DoubleEventSelectorAthenaPool.h>

Inheritance diagram for DoubleEventSelectorAthenaPool:

Collaboration diagram for DoubleEventSelectorAthenaPool:

Public Member Functions
	DoubleEventSelectorAthenaPool (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Service Constructor. More...
virtual	~DoubleEventSelectorAthenaPool ()
	Destructor. More...
virtual StatusCode	initialize () override
	Initialize function. More...
virtual StatusCode	next (IEvtSelector::Context &ctxt) const override
virtual StatusCode	next (IEvtSelector::Context &ctxt, int jump) const override
virtual StatusCode	seek (Context &ctxt, int evtNum) const override
	Seek to a given event number. More...
virtual int	size (Context &ctxt) const override
	Return the size of the collection. More...
virtual void	handle (const Incident &incident) override
	Incident service handle listening for BeginProcessing and EndProcessing. More...
virtual StatusCode	start () override
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface) override
	Does this object satisfy a given interface? See Gaudi documentation for details. More...
virtual StatusCode	createContext (IEvtSelector::Context *&ctxt) const override
	create context More...
virtual StatusCode	previous (IEvtSelector::Context &ctxt) const override
virtual StatusCode	previous (IEvtSelector::Context &ctxt, int jump) const override
virtual StatusCode	last (IEvtSelector::Context &ctxt) const override
virtual StatusCode	rewind (IEvtSelector::Context &ctxt) const override
virtual StatusCode	createAddress (const IEvtSelector::Context &ctxt, IOpaqueAddress *&iop) const override
virtual StatusCode	releaseContext (IEvtSelector::Context *&ctxt) const override
virtual StatusCode	resetCriteria (const std::string &criteria, IEvtSelector::Context &ctxt) const override
	Set a selection criteria. More...
virtual int	curEvent (const Context &ctxt) const override
	Return the current event number. More...
virtual StatusCode	makeServer (int num) override
	Make this a server. More...
virtual StatusCode	makeClient (int num) override
	Make this a client. More...
virtual StatusCode	share (int evtnum) override
	Request to share a given event number. More...
virtual StatusCode	readEvent (int maxevt) override
	Read the next maxevt events. More...
virtual StatusCode	io_reinit () override
	Callback method to reinitialize the internal state of the component for I/O purposes (e.g. upon fork(2)) More...
virtual StatusCode	io_finalize () override
	Callback method to finalize the internal state of the component for I/O purposes (e.g. before fork(2)) More...

Protected Member Functions
virtual StatusCode	nextHandleFileTransition (IEvtSelector::Context &ctxt) const override
	Handle file transition at the next iteration. More...
virtual StatusCode	nextWithSkip (IEvtSelector::Context &ctxt) const override
	Go to next event and skip if necessary. More...
virtual StatusCode	fillAttributeList (coral::AttributeList *attrList, const std::string &suffix, bool copySource) const override
	Fill AttributeList with specific items from the selector and a suffix. More...
virtual bool	disconnectIfFinished (const SG::SourceID &fid) const override

Private Types
typedef std::mutex	CallMutex

Private Member Functions
virtual StatusCode	recordAttributeList () const override
	Record AttributeList in StoreGate. More...
StoreGateSvc *	eventStore () const
	Return pointer to active event SG. More...
StatusCode	reinit () const
	Reinitialize the service when a fork() occured/was-issued. More...
PoolCollectionConverter *	getCollectionCnv (bool throwIncidents=false) const
	Return pointer to new PoolCollectionConverter. More...
int	findEvent (int evtNum) const
	Search for event with number evtNum. More...
void	fireEndFileIncidents (bool isLastFile) const
	Fires the EndInputFile incident (if there is an open file) at end of selector. More...
void	inputCollectionsHandler (Gaudi::Details::PropertyBase &)

Private Attributes
ServiceHandle< ISecondaryEventSelector >	m_secondarySelector {this, "SecondaryEventSelector", "SecondaryEventSelector", ""}
Gaudi::Property< std::string >	m_secondaryAttrListSuffix {this, "SecondaryAttrListSuffix", "secondary", ""}
bool	m_secondaryByteStream {}
SG::SlotSpecificObj< SG::SourceID >	m_sourceID1
SG::SlotSpecificObj< SG::SourceID >	m_sourceID2
EventContextAthenaPool *	m_endIter {}
PoolCollectionConverter *m_poolCollectionConverter	ATLAS_THREAD_SAFE {}
pool::ICollectionCursor *m_headerIterator	ATLAS_THREAD_SAFE {}
Guid m_guid	ATLAS_THREAD_SAFE {}
std::map< SG::SourceID, int > m_activeEventsPerSource	ATLAS_THREAD_SAFE
std::vector< std::string >::const_iterator m_inputCollectionsIterator	ATLAS_THREAD_SAFE
bool m_inputCollectionsChanged	ATLAS_THREAD_SAFE
	flag to notify the EvSel that the inputs were changed and reinit() needs to be called ASAP More...
ToolHandleArray< IAthenaSelectorTool > m_helperTools	ATLAS_THREAD_SAFE {this}
	HelperTools, vector of names of AlgTools that are executed by the EventSelector. More...
std::vector< int > m_numEvt	ATLAS_THREAD_SAFE
std::vector< int > m_firstEvt	ATLAS_THREAD_SAFE
std::vector< std::pair< long, long > > m_skipEventRanges	ATLAS_THREAD_SAFE
ServiceHandle< IAthenaPoolCnvSvc >	m_athenaPoolCnvSvc {this, "AthenaPoolCnvSvc", "AthenaPoolCnvSvc", ""}
ServiceHandle< IIncidentSvc >	m_incidentSvc {this, "IncidentSvc", "IncidentSvc", ""}
Gaudi::Property< bool >	m_isSecondary {this, "IsSecondary", false, ""}
	IsSecondary, know if this is an instance of secondary event selector. More...
Gaudi::Property< bool >	m_processMetadata {this, "ProcessMetadata", true, ""}
	ProcessMetadata, switch on firing of FileIncidents which will trigger processing of metadata: default = true. More...
Gaudi::Property< std::string >	m_collectionType {this, "CollectionType", "ImplicitROOT", ""}
	CollectionType, type of the collection: default = "ImplicitROOT". More...
Gaudi::Property< std::string >	m_collectionTree {this, "CollectionTree", APRDefaults::TTreeNames::DataHeader, ""}
	CollectionTree, prefix of the collection TTree: default = "POOLContainer". More...
Gaudi::Property< std::string >	m_connection {this, "Connection", "", ""}
	Connection, connection string. More...
Gaudi::Property< std::string >	m_refName {this, "RefName", "", ""}
	RefName, attribute name. More...
Gaudi::Property< std::string >	m_attrListKey {this, "AttributeListKey", "Input", ""}
	AttributeList SG key. More...
Gaudi::Property< std::vector< std::string > >	m_inputCollectionsProp {this, "InputCollections", {}, ""}
	InputCollections, vector with names of the input collections. More...
Gaudi::Property< std::string >	m_query {this, "Query", "", ""}
	Query string passed to APR when opening DataHeader container (kind of useless). More...
Gaudi::Property< bool >	m_keepInputFilesOpen {this, "KeepInputFilesOpen", false, ""}
	KeepInputFilesOpen, boolean flag to keep files open after PoolCollection reaches end: default = false. More...
ToolHandle< IAthenaSelectorTool >	m_counterTool {this, "CounterTool", "", ""}
ToolHandle< IAthenaIPCTool >	m_eventStreamingTool {this, "SharedMemoryTool", "", ""}
IntegerProperty	m_makeStreamingToolClient {this,"MakeStreamingToolClient",0}
	Make this instance a Streaming Client during first iteration automatically. More...
Gaudi::CheckedProperty< int >	m_runNo {this, "RunNumber", 0, ""}
	The following are included for compatibility with McEventSelector and are not really used. More...
Gaudi::CheckedProperty< int >	m_oldRunNo {this, "OldRunNumber", 0, ""}
Gaudi::Property< bool >	m_overrideRunNumber {this, "OverrideRunNumber", false, ""}
Gaudi::Property< bool >	m_overrideRunNumberFromInput {this, "OverrideRunNumberFromInput", false, ""}
Gaudi::CheckedProperty< int >	m_firstEventNo {this, "FirstEvent", 1, ""}
Gaudi::CheckedProperty< int >	m_eventsPerRun {this, "EventsPerRun", 1000000, ""}
Gaudi::CheckedProperty< int >	m_firstLBNo {this, "FirstLB", 0, ""}
Gaudi::CheckedProperty< int >	m_eventsPerLB {this, "EventsPerLB", 1000, ""}
Gaudi::CheckedProperty< int >	m_initTimeStamp {this, "InitialTimeStamp", 0, ""}
Gaudi::Property< int >	m_timeStampInterval {this, "TimeStampInterval", 0, ""}
std::atomic_long	m_curCollection {}
Gaudi::Property< int >	m_skipEvents {this, "SkipEvents", 0, ""}
	SkipEvents, numbers of events to skip: default = 0. More...
Gaudi::Property< std::vector< long > >	m_skipEventSequenceProp {this, "SkipEventSequence", {}, ""}
Gaudi::Property< std::string >	m_skipEventRangesProp {this, "SkipEventRanges", {}, ""}
	Skip Events - comma separated list of event to skip, ranges with '-': <start> - <end> More...
std::atomic_int	m_evtCount {}
std::atomic_bool	m_firedIncident {}
CallMutex	m_callLock
SG::SlotSpecificObj< SG::SourceID >	m_sourceID

Detailed Description

This class is the EventSelector for event data.

Definition at line 26 of file DoubleEventSelectorAthenaPool.h.

Member Typedef Documentation

CallMutex

typedef std::mutex EventSelectorAthenaPool::CallMutex

privateinherited

Definition at line 249 of file EventSelectorAthenaPool.h.

Constructor & Destructor Documentation

DoubleEventSelectorAthenaPool()

DoubleEventSelectorAthenaPool::DoubleEventSelectorAthenaPool	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Standard Service Constructor.

Definition at line 28 of file DoubleEventSelectorAthenaPool.cxx.

  : EventSelectorAthenaPool(name, pSvcLocator)
{
}

~DoubleEventSelectorAthenaPool()

DoubleEventSelectorAthenaPool::~DoubleEventSelectorAthenaPool ( )

virtual

Destructor.

Definition at line 34 of file DoubleEventSelectorAthenaPool.cxx.

{}

Member Function Documentation

createAddress()

StatusCode EventSelectorAthenaPool::createAddress ( const IEvtSelector::Context &  ctxt, IOpaqueAddress *&  iop  ) const

overridevirtualinherited

Parameters

ctxt	[IN] current event context.
iop	[OUT] pointer to IOpaqueAddress reference of selection context.

Definition at line 788 of file EventSelectorAthenaPool.cxx.

                                    {
   std::string tokenStr;
   SG::ReadHandle<AthenaAttributeList> attrList(m_attrListKey.value(), eventStore()->name());
   if (attrList.isValid()) {
      try {
         if (m_refName.value().empty()) {
            tokenStr = (*attrList)["eventRef"].data<std::string>();
            ATH_MSG_DEBUG("found AthenaAttribute, name = eventRef = " << tokenStr);
         } else {
            tokenStr = (*attrList)[m_refName.value() + "_ref"].data<std::string>();
            ATH_MSG_DEBUG("found AthenaAttribute, name = " << m_refName.value() << "_ref = " << tokenStr);
         }
      } catch (std::exception &e) {
         ATH_MSG_ERROR(e.what());
         return(StatusCode::FAILURE);
      }
   } else {
      ATH_MSG_WARNING("Cannot find AthenaAttribute, key = " << m_attrListKey.value());
      tokenStr = m_poolCollectionConverter->retrieveToken(m_headerIterator, m_refName.value());
   }
   Token* token = new Token;
   token->fromString(tokenStr);
   iop = new TokenAddress(POOL_StorageType, ClassID_traits<DataHeader>::ID(), "", "EventSelector", IPoolSvc::kInputStream, token);
   return(StatusCode::SUCCESS);
}

createContext()

StatusCode EventSelectorAthenaPool::createContext ( IEvtSelector::Context *&  ctxt ) const

overridevirtualinherited

create context

Definition at line 488 of file EventSelectorAthenaPool.cxx.

                                                                                  {
   ctxt = new EventContextAthenaPool(this);
   return(StatusCode::SUCCESS);
}

curEvent()

int EventSelectorAthenaPool::curEvent ( const Context &  ctxt ) const

overridevirtualinherited

Return the current event number.

Parameters

ctxt	[IN/OUT] current event context.

Definition at line 892 of file EventSelectorAthenaPool.cxx.

                                                             {
  return(m_evtCount);
}

disconnectIfFinished()

bool EventSelectorAthenaPool::disconnectIfFinished ( const SG::SourceID &  fid ) const

overrideprotectedvirtualinherited

Definition at line 1248 of file EventSelectorAthenaPool.cxx.

{
   if( m_eventStreamingTool.empty() && m_activeEventsPerSource.find(fid) != m_activeEventsPerSource.end() 
           && m_activeEventsPerSource[fid] <= 0 && m_guid != fid ) {
      // Explicitly disconnect file corresponding to old FID to release memory
      if( !m_keepInputFilesOpen.value() ) {
         // Assume that the end of collection file indicates the end of payload file.
         if (m_processMetadata.value()) {
            FileIncident endInputFileIncident(name(), "EndInputFile", "FID:" + fid, fid);
            m_incidentSvc->fireIncident(endInputFileIncident);
         }
         ATH_MSG_INFO("Disconnecting input sourceID: " << fid );
         m_athenaPoolCnvSvc->getPoolSvc()->disconnectDb("FID:" + fid, IPoolSvc::kInputStream).ignore();
         m_activeEventsPerSource.erase( fid );
         return true;
      }
   }
   return false;
}

eventStore()

StoreGateSvc * EventSelectorAthenaPool::eventStore ( ) const

privateinherited

Return pointer to active event SG.

Definition at line 85 of file EventSelectorAthenaPool.cxx.

                                                        {
   return StoreGateSvc::currentStoreGate();
}

fillAttributeList()

StatusCode EventSelectorAthenaPool::fillAttributeList ( coral::AttributeList *  attrList, const std::string &  suffix, bool  copySource  ) const

overrideprotectedvirtualinherited

Fill AttributeList with specific items from the selector and a suffix.

Definition at line 1112 of file EventSelectorAthenaPool.cxx.

{
   const pool::TokenList& tokenList = m_headerIterator->currentRow().tokenList();
   for (pool::TokenList::const_iterator iter = tokenList.begin(), last = tokenList.end(); iter != last; ++iter) {
      attrList->extend(iter.tokenName() + suffix, "string");
      (*attrList)[iter.tokenName() + suffix].data<std::string>() = iter->toString();
      ATH_MSG_DEBUG("record AthenaAttribute, name = " << iter.tokenName() + suffix << " = " << iter->toString() << ".");
   }
 
   std::string eventRef = "eventRef";
   if (m_isSecondary.value()) {
      eventRef.append(suffix);
   }
   attrList->extend(eventRef, "string");
   (*attrList)[eventRef].data<std::string>() = m_headerIterator->eventRef().toString();
   ATH_MSG_DEBUG("record AthenaAttribute, name = " + eventRef + " = " <<  m_headerIterator->eventRef().toString() << ".");
 
   if (copySource) {
      const coral::AttributeList& sourceAttrList = m_headerIterator->currentRow().attributeList();
      for (const auto &attr : sourceAttrList) {
         attrList->extend(attr.specification().name() + suffix, attr.specification().type());
         (*attrList)[attr.specification().name() + suffix] = attr;
      }
   }
 
   return StatusCode::SUCCESS;
}

finalize()

StatusCode EventSelectorAthenaPool::finalize ( )

overridevirtualinherited

Definition at line 427 of file EventSelectorAthenaPool.cxx.

                                             {
   if (m_eventStreamingTool.empty() || !m_eventStreamingTool->isClient()) {
      if (!m_counterTool.empty() && !m_counterTool->preFinalize().isSuccess()) {
         ATH_MSG_WARNING("Failed to preFinalize() CounterTool");
      }
      for (auto& tool : m_helperTools) {
         if (!tool->preFinalize().isSuccess()) {
            ATH_MSG_WARNING("Failed to preFinalize() " << tool->name());
         }
      }
   }
   delete m_endIter;   m_endIter   = nullptr;
   m_headerIterator = nullptr;
   if (m_poolCollectionConverter != nullptr) {
      delete m_poolCollectionConverter; m_poolCollectionConverter = nullptr;
   }
   // Release AthenaSharedMemoryTool
   if (!m_eventStreamingTool.empty() && !m_eventStreamingTool.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release AthenaSharedMemoryTool");
   }
   // Release CounterTool
   if (!m_counterTool.empty() && !m_counterTool.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release CounterTool.");
   }
   // Release HelperTools
   if (!m_helperTools.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release " << m_helperTools);
   }
   // Release AthenaPoolCnvSvc
   if (!m_athenaPoolCnvSvc.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release " << m_athenaPoolCnvSvc.typeAndName() << ".");
   }
   // Release IncidentSvc
   if (!m_incidentSvc.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release " << m_incidentSvc.typeAndName() << ".");
   }
   // Finalize the Service base class.
   return(::AthService::finalize());
}

findEvent()

int EventSelectorAthenaPool::findEvent ( int  evtNum ) const

privateinherited

Search for event with number evtNum.

Definition at line 900 of file EventSelectorAthenaPool.cxx.

                                                       {
   for (std::size_t i = 0, imax = m_numEvt.size(); i < imax; i++) {
      if (m_numEvt[i] == -1) {
         PoolCollectionConverter pcc(m_collectionType.value() + ":" + m_collectionTree.value(),
             m_inputCollectionsProp.value()[i],
             IPoolSvc::kInputStream,
             m_query.value(),
             m_athenaPoolCnvSvc->getPoolSvc());
         if (!pcc.initialize().isSuccess()) {
            break;
         }
         int collection_size = 0;
         if (pcc.isValid()) {
            pool::ICollectionCursor* hi = &pcc.executeQuery();
            ICollectionSize* cs = dynamic_cast<ICollectionSize*>(hi);
            if (cs == nullptr) {
               break;
            }
            collection_size = cs->size();
         }
         if (i > 0) {
            m_firstEvt[i] = m_firstEvt[i - 1] + m_numEvt[i - 1];
         } else {
            m_firstEvt[i] = 0;
         }
         m_numEvt[i] = collection_size;
      }
      if (evtNum >= m_firstEvt[i] && evtNum < m_firstEvt[i] + m_numEvt[i]) {
         return(i);
      }
   }
   return(-1);
}

fireEndFileIncidents()

void EventSelectorAthenaPool::fireEndFileIncidents ( bool  isLastFile ) const

privateinherited

Fires the EndInputFile incident (if there is an open file) at end of selector.

Definition at line 410 of file EventSelectorAthenaPool.cxx.

                                                                        {
   if (m_processMetadata.value()) {
      if (m_evtCount >= 0) {
         // Assume that the end of collection file indicates the end of payload file.
         if (m_guid != Guid::null()) {
            // Fire EndInputFile incident
            FileIncident endInputFileIncident(name(), "EndInputFile", "FID:" + m_guid.toString(), m_guid.toString());
            m_incidentSvc->fireIncident(endInputFileIncident);
         }
      }
      if (isLastFile && m_firedIncident) {
         m_firedIncident = false;
      }
   }
}

getCollectionCnv()

PoolCollectionConverter * EventSelectorAthenaPool::getCollectionCnv ( bool  throwIncidents = false ) const

privateinherited

Return pointer to new PoolCollectionConverter.

Definition at line 1050 of file EventSelectorAthenaPool.cxx.

                                                                                            {
   while (m_inputCollectionsIterator != m_inputCollectionsProp.value().end()) {
      if (m_curCollection != 0) {
         m_numEvt[m_curCollection] = m_evtCount - m_firstEvt[m_curCollection];
         m_curCollection++;
         m_firstEvt[m_curCollection] = m_evtCount;
      }
      ATH_MSG_DEBUG("Try item: \"" << *m_inputCollectionsIterator << "\" from the collection list.");
      PoolCollectionConverter* pCollCnv = new PoolCollectionConverter(m_collectionType.value() + ":" + m_collectionTree.value(),
          *m_inputCollectionsIterator,
          IPoolSvc::kInputStream,
          m_query.value(),
          m_athenaPoolCnvSvc->getPoolSvc());
      StatusCode status = pCollCnv->initialize();
      if (!status.isSuccess()) {
         // Close previous collection.
         delete pCollCnv; pCollCnv = nullptr;
         if (!status.isRecoverable()) {
            ATH_MSG_ERROR("Unable to initialize PoolCollectionConverter.");
            throw GaudiException("Unable to read: " + *m_inputCollectionsIterator, name(), StatusCode::FAILURE);
         } else {
            ATH_MSG_ERROR("Unable to open: " << *m_inputCollectionsIterator);
            throw GaudiException("Unable to open: " + *m_inputCollectionsIterator, name(), StatusCode::FAILURE);
         }
      } else {
         if (!pCollCnv->isValid().isSuccess()) {
            delete pCollCnv; pCollCnv = nullptr;
            ATH_MSG_DEBUG("No events found in: " << *m_inputCollectionsIterator << " skipped!!!");
            if (throwIncidents && m_processMetadata.value()) {
               FileIncident beginInputFileIncident(name(), "BeginInputFile", *m_inputCollectionsIterator);
               m_incidentSvc->fireIncident(beginInputFileIncident);
               FileIncident endInputFileIncident(name(), "EndInputFile", "eventless " + *m_inputCollectionsIterator);
               m_incidentSvc->fireIncident(endInputFileIncident);
            }
            m_athenaPoolCnvSvc->getPoolSvc()->disconnectDb(*m_inputCollectionsIterator).ignore();
            ++m_inputCollectionsIterator;
         } else {
            return(pCollCnv);
         }
      }
   }
   return(nullptr);
}

handle()

void DoubleEventSelectorAthenaPool::handle ( const Incident &  incident )

overridevirtual

Incident service handle listening for BeginProcessing and EndProcessing.

Reimplemented from EventSelectorAthenaPool.

Definition at line 199 of file DoubleEventSelectorAthenaPool.cxx.

{
  ATH_MSG_DEBUG("DoubleEventSelectorAthenaPool::handle");
 
   if (not Atlas::hasExtendedEventContext(inc.context()) ) {
    ATH_MSG_WARNING("No extended event context available.");
    return;
  }
 
   SG::SourceID fid1;
   if (inc.type() == IncidentType::BeginProcessing) {
     if ( Atlas::hasExtendedEventContext(inc.context()) ) {
       fid1 = Atlas::getExtendedEventContext(inc.context()).proxy()->sourceID();
     }
     *m_sourceID1.get(inc.context()) = fid1;
   }
   else {
     fid1 = *m_sourceID1.get(inc.context());
   }
 
  if( fid1.empty() ) {
    ATH_MSG_WARNING("could not read event source ID from incident event context with key EventSelector");
    return;
  }
 
  ATH_MSG_DEBUG("**  MN Incident handler " << inc.type() << " Event source ID=" << fid1 );
  if( inc.type() == IncidentType::BeginProcessing ) {
    // increment the events-per-file counter for FID
    m_activeEventsPerSource[fid1]++;
  } else if( inc.type() == IncidentType::EndProcessing ) {
    m_activeEventsPerSource[fid1]--;
    disconnectIfFinished( fid1 );
    *m_sourceID1.get(inc.context()) = "";
  }
  if( msgLvl(MSG::DEBUG) ) {
    for( auto& source: m_activeEventsPerSource )
      msg(MSG::DEBUG) << "SourceID: " << source.first << " active events: " << source.second << endmsg;
  }
 
  // Nothing to do if secondary event selector is ByteStream
  if (m_secondaryByteStream) {
    return;
  }
 
  // Secondary guid
  SG::SourceID fid2;
  if (inc.type() == IncidentType::BeginProcessing) {
    if ( Atlas::hasExtendedEventContext(inc.context()) ) {
      fid2 = Atlas::getExtendedEventContext(inc.context()).proxy()->sourceID("SecondaryEventSelector");
    }
    *m_sourceID2.get(inc.context()) = fid2;
  }
  else {
    fid2 = *m_sourceID2.get(inc.context());
  }
 
  if( fid2.empty() ) {
    ATH_MSG_WARNING("could not read event source ID from incident event context with key SecondaryEventSelector");
    return;
  }
 
  ATH_MSG_DEBUG("**  MN Incident handler " << inc.type() << " Event source ID=" << fid2 );
  if( inc.type() == IncidentType::BeginProcessing ) {
    // increment the events-per-file counter for FID
    m_activeEventsPerSource[fid2]++;
  } else if( inc.type() == IncidentType::EndProcessing ) {
    m_activeEventsPerSource[fid2]--;
    m_secondarySelector->disconnectIfFinished( fid2 );
    *m_sourceID2.get(inc.context()) = "";
  }
  if( msgLvl(MSG::DEBUG) ) {
    for( auto& source: m_activeEventsPerSource )
      msg(MSG::DEBUG) << "SourceID: " << source.first << " active events: " << source.second << endmsg;
  }
}

initialize()

StatusCode DoubleEventSelectorAthenaPool::initialize ( )

overridevirtual

Initialize function.

Reimplemented from EventSelectorAthenaPool.

Definition at line 37 of file DoubleEventSelectorAthenaPool.cxx.

{
  ATH_CHECK(EventSelectorAthenaPool::initialize());
 
  ATH_CHECK(m_secondarySelector.retrieve());
  if (dynamic_cast<EventSelectorAthenaPool *>(&*(m_secondarySelector)) == nullptr) {
    m_secondaryByteStream = true;
  }
 
  return StatusCode::SUCCESS;
}

inputCollectionsHandler()

void EventSelectorAthenaPool::inputCollectionsHandler ( Gaudi::Details::PropertyBase &  )

privateinherited

Definition at line 76 of file EventSelectorAthenaPool.cxx.

                                                                               {
   if (this->FSMState() != Gaudi::StateMachine::OFFLINE) {
      m_inputCollectionsChanged = true;
   }
}

io_finalize()

StatusCode EventSelectorAthenaPool::io_finalize ( )

overridevirtualinherited

Callback method to finalize the internal state of the component for I/O purposes (e.g. before fork(2))

Definition at line 1192 of file EventSelectorAthenaPool.cxx.

                                                {
   ATH_MSG_INFO("I/O finalization...");
   if (m_poolCollectionConverter != nullptr) {
      m_poolCollectionConverter->disconnectDb().ignore();
      delete m_poolCollectionConverter; m_poolCollectionConverter = nullptr;
   }
   return(StatusCode::SUCCESS);
}

io_reinit()

StatusCode EventSelectorAthenaPool::io_reinit ( )

overridevirtualinherited

Callback method to reinitialize the internal state of the component for I/O purposes (e.g. upon fork(2))

Definition at line 1140 of file EventSelectorAthenaPool.cxx.

                                              {
   ATH_MSG_INFO("I/O reinitialization...");
   if (m_poolCollectionConverter != nullptr) {
      m_poolCollectionConverter->disconnectDb().ignore();
      delete m_poolCollectionConverter; m_poolCollectionConverter = nullptr;
   }
   m_headerIterator = nullptr;
   ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
   if (!iomgr.retrieve().isSuccess()) {
      ATH_MSG_FATAL("Could not retrieve IoComponentMgr !");
      return(StatusCode::FAILURE);
   }
   if (!iomgr->io_hasitem(this)) {
      ATH_MSG_FATAL("IoComponentMgr does not know about myself !");
      return(StatusCode::FAILURE);
   }
   if (!m_eventStreamingTool.empty() && m_eventStreamingTool->isClient()) {
      m_guid = Guid::null();
      return(this->reinit());
   }
   std::vector<std::string> inputCollections = m_inputCollectionsProp.value();
   std::set<std::size_t> updatedIndexes;
   for (std::size_t i = 0, imax = m_inputCollectionsProp.value().size(); i < imax; i++) {
      if (updatedIndexes.find(i) != updatedIndexes.end()) continue;
      std::string savedName = inputCollections[i];
      std::string &fname = inputCollections[i];
      if (!iomgr->io_contains(this, fname)) {
         ATH_MSG_ERROR("IoComponentMgr does not know about [" << fname << "] !");
         return(StatusCode::FAILURE);
      }
      if (!iomgr->io_retrieve(this, fname).isSuccess()) {
         ATH_MSG_FATAL("Could not retrieve new value for [" << fname << "] !");
         return(StatusCode::FAILURE);
      }
      if (savedName != fname) {
         ATH_MSG_DEBUG("Mapping value for [" << savedName << "] to [" << fname << "]");
         m_athenaPoolCnvSvc->getPoolSvc()->renamePfn(savedName, fname);
      }
      updatedIndexes.insert(i);
      for (std::size_t j = i + 1; j < imax; j++) {
         if (inputCollections[j] == savedName) {
            inputCollections[j] = fname;
            updatedIndexes.insert(j);
         }
      }
   }
   // all good... copy over.
   m_inputCollectionsProp = inputCollections;
   m_guid = Guid::null();
   return reinit();
}

last()

StatusCode EventSelectorAthenaPool::last ( IEvtSelector::Context &  ctxt ) const

overridevirtualinherited

Parameters

ctxt	[IN/OUT] current event context is interated to last event.

Definition at line 774 of file EventSelectorAthenaPool.cxx.

                                                                        {
   if (ctxt.identifier() == m_endIter->identifier()) {
      ATH_MSG_DEBUG("last(): Last event in InputStream.");
      return(StatusCode::SUCCESS);
   }
   return(StatusCode::FAILURE);
}

makeClient()

StatusCode EventSelectorAthenaPool::makeClient ( int  num )

overridevirtualinherited

Make this a client.

Definition at line 955 of file EventSelectorAthenaPool.cxx.

                                                      {
   if (m_athenaPoolCnvSvc->makeClient(num + 1).isFailure()) {
      ATH_MSG_ERROR("Failed to switch AthenaPoolCnvSvc to DataStreaming client");
      return(StatusCode::FAILURE);
   }
   if (m_eventStreamingTool.empty()) {
      return(StatusCode::SUCCESS);
   }
   ATH_MSG_DEBUG("makeClient: " << m_eventStreamingTool << " = " << num);
   std::string dummyStr;
   return(m_eventStreamingTool->makeClient(0, dummyStr));
}

makeServer()

StatusCode EventSelectorAthenaPool::makeServer ( int  num )

overridevirtualinherited

Make this a server.

Definition at line 935 of file EventSelectorAthenaPool.cxx.

                                                      {
   if (num < 0) {
      if (m_athenaPoolCnvSvc->makeServer(num - 1).isFailure()) {
         ATH_MSG_ERROR("Failed to switch AthenaPoolCnvSvc to output DataStreaming server");
      }
      return(StatusCode::SUCCESS);
   }
   if (m_athenaPoolCnvSvc->makeServer(num + 1).isFailure()) {
      ATH_MSG_ERROR("Failed to switch AthenaPoolCnvSvc to input DataStreaming server");
      return(StatusCode::FAILURE);
   }
   if (m_eventStreamingTool.empty()) {
      return(StatusCode::SUCCESS);
   }
   m_processMetadata = false;
   ATH_MSG_DEBUG("makeServer: " << m_eventStreamingTool << " = " << num);
   return(m_eventStreamingTool->makeServer(1, ""));
}

next() [1/2]

StatusCode DoubleEventSelectorAthenaPool::next ( IEvtSelector::Context &  ctxt ) const

overridevirtual

Parameters

ctxt	[IN/OUT] current event context is interated to next event.

Reimplemented from EventSelectorAthenaPool.

Definition at line 50 of file DoubleEventSelectorAthenaPool.cxx.

{
  ATH_MSG_DEBUG("DoubleEventSelectorAthenaPool::next");
 
  std::lock_guard<CallMutex> lockGuard(m_callLock);
  if (!eventStore()->clearStore().isSuccess()) {
    ATH_MSG_WARNING("Cannot clear Store");
  }
  for (const auto& tool : m_helperTools) {
    if (!tool->preNext().isSuccess()) {
        ATH_MSG_WARNING("Failed to preNext() " << tool->name());
    }
  }
 
  for (;;) {
    // Move in the primary file (with skipping)
    if (nextWithSkip(ctxt).isFailure()) {
      return StatusCode::FAILURE;
    }
 
    // Check if we're at the end of secondary file
    if (m_secondarySelector->nextWithSkip(ctxt).isFailure()) {
      return StatusCode::FAILURE;
    }
 
    // Record the attribute list
    if (!recordAttributeList().isSuccess()) {
      ATH_MSG_ERROR("Failed to record AttributeList.");
      return StatusCode::FAILURE;
    }
 
    StatusCode status = StatusCode::SUCCESS;
    for (const auto& tool : m_helperTools) {
      StatusCode toolStatus = tool->postNext();
      if (toolStatus.isRecoverable()) {
          ATH_MSG_INFO("Request skipping event from: " << tool->name());
          if (status.isSuccess()) {
            status = StatusCode::RECOVERABLE;
          }
      } else if (toolStatus.isFailure()) {
          ATH_MSG_WARNING("Failed to postNext() " << tool->name());
          status = StatusCode::FAILURE;
      }
    }
    if (status.isRecoverable()) {
      ATH_MSG_INFO("skipping event " << m_evtCount);
    } else if (status.isFailure()) {
      ATH_MSG_WARNING("Failed to postNext() HelperTool.");
    } else {
      if (!m_counterTool.empty() && !m_counterTool->postNext().isSuccess()) {
          ATH_MSG_WARNING("Failed to postNext() CounterTool.");
      }
      break;
    }
  }
 
  return StatusCode::SUCCESS;
}

next() [2/2]

StatusCode DoubleEventSelectorAthenaPool::next ( IEvtSelector::Context &  ctxt, int  jump  ) const

overridevirtual

Parameters

ctxt	[IN/OUT] current event context is interated to next event.
jump	[IN] number of events to jump (currently not supported).

Reimplemented from EventSelectorAthenaPool.

Definition at line 110 of file DoubleEventSelectorAthenaPool.cxx.

{
  ATH_MSG_DEBUG("DoubleEventSelectorAthenaPool::next(jump)");
 
  if (jump > 0) {
    for (int i = 0; i < jump; i++) {
      if (!next(ctxt).isSuccess()) {
        return StatusCode::FAILURE;
      }
    }
    return StatusCode::SUCCESS;
  }
 
  return StatusCode::FAILURE;
}

nextHandleFileTransition()

StatusCode EventSelectorAthenaPool::nextHandleFileTransition ( IEvtSelector::Context &  ctxt ) const

overrideprotectedvirtualinherited

Handle file transition at the next iteration.

Definition at line 639 of file EventSelectorAthenaPool.cxx.

{
   if( m_inputCollectionsChanged ) {
      StatusCode rc = reinit();
      if( rc != StatusCode::SUCCESS ) return rc;
   }
   else {   // advance to the next (not needed after reinit)
      // Check if we're at the end of file
      if (m_headerIterator == nullptr || m_headerIterator->next() == 0) {
         m_headerIterator = nullptr;
         // Close previous collection.
         delete m_poolCollectionConverter; m_poolCollectionConverter = nullptr;
 
         // zero the current DB ID (m_guid) before disconnect() to indicate it is no longer in use
         const SG::SourceID old_guid = m_guid.toString();
         m_guid = Guid::null();
         disconnectIfFinished( old_guid );
 
         // check if somebody updated Inputs in the EOF incident (like VP1 does)
         if( m_inputCollectionsChanged ) {
            StatusCode rc = reinit();
            if( rc != StatusCode::SUCCESS ) return rc;
         } else {
            // Open next file from inputCollections list.
            ++m_inputCollectionsIterator;
            // Create PoolCollectionConverter for input file
            m_poolCollectionConverter = getCollectionCnv(true);
            if (m_poolCollectionConverter == nullptr) {
               // Return end iterator
               ctxt = *m_endIter;
               // This is not a real failure but a Gaudi way of handling "end of job"
               return StatusCode::FAILURE;
            }
            // Get DataHeader iterator
            m_headerIterator = &m_poolCollectionConverter->executeQuery();
 
            // Return RECOVERABLE to mark we should still continue
            return StatusCode::RECOVERABLE;
         }
      }
   }
 
   const Token& headRef = m_refName.value().empty()?
      m_headerIterator->eventRef()
      : m_headerIterator->currentRow().tokenList()[m_refName.value() + "_ref"];
   const Guid guid = headRef.dbID();
   const int tech = headRef.technology();
   ATH_MSG_VERBOSE("next(): DataHeder Token=" << headRef.toString() );
 
   if (guid != m_guid) {
      // we are starting reading from a new DB. Check if the old one needs to be retired
      if (m_guid != Guid::null()) {
         // zero the current DB ID (m_guid) before trying disconnect() to indicate it is no longer in use
         const SG::SourceID old_guid = m_guid.toString();
         m_guid = Guid::null();
         disconnectIfFinished( old_guid );
      }
      m_guid = guid;
      m_activeEventsPerSource[guid.toString()] = 0;
      // Fire BeginInputFile incident if current InputCollection is a payload file;
      // otherwise, ascertain whether the pointed-to file is reachable before firing any incidents and/or proceeding
      if (m_collectionType.value() == "ImplicitROOT") {
         // For now, we can only deal with input metadata from POOL files, but we know we have a POOL file here
         if (!m_athenaPoolCnvSvc->setInputAttributes(*m_inputCollectionsIterator).isSuccess()) {
               ATH_MSG_ERROR("Failed to set input attributes.");
               return(StatusCode::FAILURE);
         }
         if (m_processMetadata.value()) {
            FileIncident beginInputFileIncident(name(), "BeginInputFile", *m_inputCollectionsIterator, m_guid.toString());
            m_incidentSvc->fireIncident(beginInputFileIncident);
         }
      } else {
         // Check if File is BS
         if (tech != 0x00001000 && m_processMetadata.value()) {
            FileIncident beginInputFileIncident(name(), "BeginInputFile", "FID:" + m_guid.toString(), m_guid.toString());
            m_incidentSvc->fireIncident(beginInputFileIncident);
         }
      }
   }  // end if (guid != m_guid)
   return StatusCode::SUCCESS;
}

nextWithSkip()

StatusCode EventSelectorAthenaPool::nextWithSkip ( IEvtSelector::Context &  ctxt ) const

overrideprotectedvirtualinherited

Go to next event and skip if necessary.

Definition at line 721 of file EventSelectorAthenaPool.cxx.

                                                                                {
   ATH_MSG_DEBUG("EventSelectorAthenaPool::nextWithSkip");
 
   for (;;) {
      // Check if we're at the end of file
      StatusCode sc = nextHandleFileTransition(ctxt);
      if (sc.isRecoverable()) {
         continue; // handles empty files
      }
      if (sc.isFailure()) {
         return StatusCode::FAILURE;
      }
 
      // Increase event count
      ++m_evtCount;
 
      if (!m_counterTool.empty() && !m_counterTool->preNext().isSuccess()) {
         ATH_MSG_WARNING("Failed to preNext() CounterTool.");
      }
      if( m_evtCount > m_skipEvents
         && (m_skipEventRanges.empty() || m_evtCount < m_skipEventRanges.front().first))
      {
         return StatusCode::SUCCESS;
      } else {
         while( !m_skipEventRanges.empty() && m_evtCount >= m_skipEventRanges.front().second ) {
            m_skipEventRanges.erase(m_skipEventRanges.begin());
         }
         if (m_isSecondary.value()) {
            ATH_MSG_INFO("skipping secondary event " << m_evtCount);
         } else {
            ATH_MSG_INFO("skipping event " << m_evtCount);
         }
      }
   }
 
   return StatusCode::SUCCESS;
}

previous() [1/2]

StatusCode EventSelectorAthenaPool::previous ( IEvtSelector::Context &  ctxt ) const

overridevirtualinherited

Parameters

ctxt	[IN/OUT] current event context is interated to previous event.

Definition at line 759 of file EventSelectorAthenaPool.cxx.

                                                                         {
   ATH_MSG_ERROR("previous() not implemented");
   return(StatusCode::FAILURE);
}

previous() [2/2]

StatusCode EventSelectorAthenaPool::previous ( IEvtSelector::Context &  ctxt, int  jump  ) const

overridevirtualinherited

Parameters

ctxt	[IN/OUT] current event context is interated to previous event.
jump	[IN] number of events to jump (currently not supported).

Definition at line 764 of file EventSelectorAthenaPool.cxx.

                                                                                      {
   if (jump > 0) {
      for (int i = 0; i < jump; i++) {
         ATH_CHECK(previous(ctxt));
      }
      return(StatusCode::SUCCESS);
   }
   return(StatusCode::FAILURE);
}

queryInterface()

StatusCode EventSelectorAthenaPool::queryInterface ( const InterfaceID &  riid, void **  ppvInterface  )

overridevirtualinherited

Does this object satisfy a given interface? See Gaudi documentation for details.

Definition at line 468 of file EventSelectorAthenaPool.cxx.

                                                                                               {
   if (riid == IEvtSelector::interfaceID()) {
      *ppvInterface = dynamic_cast<IEvtSelector*>(this);
   } else if (riid == IIoComponent::interfaceID()) {
      *ppvInterface = dynamic_cast<IIoComponent*>(this);
   } else if (riid == IProperty::interfaceID()) {
      *ppvInterface = dynamic_cast<IProperty*>(this);
   } else if (riid == IEvtSelectorSeek::interfaceID()) {
      *ppvInterface = dynamic_cast<IEvtSelectorSeek*>(this);
   } else if (riid == IEventShare::interfaceID()) {
      *ppvInterface = dynamic_cast<IEventShare*>(this);
   } else if (riid == ISecondaryEventSelector::interfaceID()) {
      *ppvInterface = dynamic_cast<ISecondaryEventSelector*>(this);
   } else {
      return(::AthService::queryInterface(riid, ppvInterface));
   }
   addRef();
   return(StatusCode::SUCCESS);
}

readEvent()

StatusCode EventSelectorAthenaPool::readEvent ( int  maxevt )

overridevirtualinherited

Read the next maxevt events.

Parameters

evtnum

[IN] The number of events to read.

Definition at line 997 of file EventSelectorAthenaPool.cxx.

                                                        {
   if (m_eventStreamingTool.empty()) {
      ATH_MSG_ERROR("No AthenaSharedMemoryTool configured for readEvent()");
      return(StatusCode::FAILURE);
   }
   ATH_MSG_VERBOSE("Called read Event " << maxevt);
   IEvtSelector::Context* ctxt = new EventContextAthenaPool(this);
   for (int i = 0; i < maxevt || maxevt == -1; ++i) {
      if (!next(*ctxt).isSuccess()) {
         if (m_evtCount == -1) {
            ATH_MSG_VERBOSE("Called read Event and read last event from input: " << i);
            break;
         }
         ATH_MSG_ERROR("Cannot read Event " << m_evtCount - 1 << " into AthenaSharedMemoryTool");
         delete ctxt; ctxt = nullptr;
         return(StatusCode::FAILURE);
      } else {
         ATH_MSG_VERBOSE("Called next, read Event " << m_evtCount - 1);
      }
   }
   delete ctxt; ctxt = nullptr;
   // End of file, wait for last event to be taken
   StatusCode sc;
   while ( (sc = putEvent_ST(*m_eventStreamingTool, 0, 0, 0, 0)).isRecoverable() ) {
      while (m_athenaPoolCnvSvc->readData().isSuccess()) {
         ATH_MSG_VERBOSE("Called last readData, while marking last event in readEvent()");
      }
      usleep(1000);
   }
   if (!sc.isSuccess()) {
      ATH_MSG_ERROR("Cannot put last Event marker to AthenaSharedMemoryTool");
      return(StatusCode::FAILURE);
   } else {
      sc = m_athenaPoolCnvSvc->readData();
      while (sc.isSuccess() || sc.isRecoverable()) {
         sc = m_athenaPoolCnvSvc->readData();
      }
      ATH_MSG_DEBUG("Failed last readData -> Clients are stopped, after marking last event in readEvent()");
   }
   return(StatusCode::SUCCESS);
}

recordAttributeList()

StatusCode DoubleEventSelectorAthenaPool::recordAttributeList ( ) const

overrideprivatevirtual

Record AttributeList in StoreGate.

Reimplemented from EventSelectorAthenaPool.

Definition at line 153 of file DoubleEventSelectorAthenaPool.cxx.

{
  ATH_MSG_DEBUG("DoubleEventSelectorAthenaPool::recordAttributeList");
 
  // Get access to AttributeList
  ATH_MSG_DEBUG("Get AttributeList from the collection");
  // MN: accessing only attribute list, ignoring token list
  const coral::AttributeList& attrList = m_headerIterator->currentRow().attributeList();
  ATH_MSG_DEBUG("AttributeList size " << attrList.size());
  std::unique_ptr<AthenaAttributeList> athAttrList{};
 
  // Decide what to do based on the type of secondary file
  if (m_secondaryByteStream) {
    // Create empty attribute list
    athAttrList = std::make_unique<AthenaAttributeList>();
    // Always add ByteStream as primary input
    ATH_CHECK(m_secondarySelector->fillAttributeList(athAttrList.get(), "", false));
 
    // Then fill the new attribute list from the primary file
    ATH_MSG_DEBUG("Append primary attribute list properties to the secondary one with a suffix: " << m_secondaryAttrListSuffix.value());
    ATH_CHECK(fillAttributeList(athAttrList.get(), "_" + m_secondaryAttrListSuffix.value(), true));
  } else {
    // Create a new attribute list from the primary input one
    athAttrList = std::make_unique<AthenaAttributeList>(attrList);
    // Fill the new attribute list from the primary file
    ATH_CHECK(fillAttributeList(athAttrList.get(), "", false));
 
    // Fill the new attribute list from the secondary file
    ATH_MSG_DEBUG("Append secondary attribute list properties to the primary one with a suffix: " << m_secondaryAttrListSuffix.value());
    ATH_CHECK(m_secondarySelector->fillAttributeList(athAttrList.get(), "_" + m_secondaryAttrListSuffix.value(), true));
  }
 
  // Add info about secondary input
  athAttrList->extend("hasSecondaryInput", "bool");
  (*athAttrList)["hasSecondaryInput"].data<bool>() = true;
 
  SG::WriteHandle<AthenaAttributeList> wh(m_attrListKey.value(), eventStore()->name());
  if (!wh.record(std::move(athAttrList)).isSuccess()) {
    ATH_MSG_ERROR("Cannot record AttributeList to StoreGate " << StoreID::storeName(eventStore()->storeID()));
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

reinit()

StatusCode EventSelectorAthenaPool::reinit ( ) const

privateinherited

Reinitialize the service when a fork() occured/was-issued.

Definition at line 247 of file EventSelectorAthenaPool.cxx.

                                                 {
   ATH_MSG_DEBUG("reinitialization...");
 
   // reset markers
   m_numEvt.resize(m_inputCollectionsProp.value().size(), -1);
   for( auto& el : m_numEvt ) el = -1;
   m_firstEvt.resize(m_inputCollectionsProp.value().size(), -1);
   for( auto& el : m_firstEvt ) el = -1;
 
   // Initialize InputCollectionsIterator
   m_inputCollectionsIterator = m_inputCollectionsProp.value().begin();
   m_curCollection = 0;
   if (!m_firstEvt.empty()) {
      m_firstEvt[0] = 0;
   }
   m_inputCollectionsChanged = false;
   m_evtCount = 0;
   m_headerIterator = 0;
   if (!m_eventStreamingTool.empty() && m_eventStreamingTool->isClient()) {
      ATH_MSG_INFO("Done reinitialization for shared reader client");
      return(StatusCode::SUCCESS);
   }
   bool retError = false;
   for (auto& tool : m_helperTools) {
      if (!tool->postInitialize().isSuccess()) {
         ATH_MSG_FATAL("Failed to postInitialize() " << tool->name());
         retError = true;
      }
   }
   if (retError) {
      ATH_MSG_FATAL("Failed to postInitialize() helperTools");
      return(StatusCode::FAILURE);
   }
 
   ATH_MSG_INFO("EventSelection with query " << m_query.value());
   // Create an m_poolCollectionConverter to read the objects in
   m_poolCollectionConverter = getCollectionCnv();
   if (m_poolCollectionConverter == nullptr) {
      ATH_MSG_INFO("No Events found in any Input Collections");
      if (m_processMetadata.value()) {
     m_inputCollectionsIterator = m_inputCollectionsProp.value().end();
     if (!m_inputCollectionsProp.value().empty()) --m_inputCollectionsIterator;
    //NOTE (wb may 2016): this will make the FirstInputFile incident correspond to last file in the collection ... if want it to be first file then move iterator to begin and then move above two lines below this incident firing
         if (m_collectionType.value() == "ImplicitROOT" && !m_firedIncident && !m_inputCollectionsProp.value().empty()) {
            FileIncident firstInputFileIncident(name(), "FirstInputFile", *m_inputCollectionsIterator);
            m_incidentSvc->fireIncident(firstInputFileIncident);
            m_firedIncident = true;
         }
      }
      return(StatusCode::SUCCESS);
   }
   // Check for valid header name
   if (!m_refName.value().empty()) {
      if (m_collectionType.value() == "ExplicitROOT") {
            ATH_MSG_INFO("Using collection ref name: " << m_refName.value());
      } else {
         ATH_MSG_INFO("Using implicit collection, ignore ref name: " << m_refName.value());
      }
   } else if (m_collectionType.value() == "ExplicitROOT") {
      ATH_MSG_INFO("Using standard collection ref ");
   }
   // Get DataHeader iterator
   try {
      m_headerIterator = &m_poolCollectionConverter->executeQuery();
   } catch (std::exception &e) {
      ATH_MSG_FATAL("Cannot open implicit collection - check data/software version.");
      ATH_MSG_ERROR(e.what());
      return(StatusCode::FAILURE);
   }
   while (m_headerIterator == nullptr || m_headerIterator->next() == 0) { // no selected events
      if (m_poolCollectionConverter != nullptr) {
         m_poolCollectionConverter->disconnectDb().ignore();
         delete m_poolCollectionConverter; m_poolCollectionConverter = nullptr;
      }
      ++m_inputCollectionsIterator;
      m_poolCollectionConverter = getCollectionCnv();
      if (m_poolCollectionConverter != nullptr) {
         m_headerIterator = &m_poolCollectionConverter->executeQuery();
      } else {
         break;
      }
   }
   if (m_poolCollectionConverter == nullptr || m_headerIterator == nullptr) { // no event selected in any collection
      m_inputCollectionsIterator = m_inputCollectionsProp.value().begin();
      m_curCollection = 0;
      m_poolCollectionConverter = getCollectionCnv();
      if (m_poolCollectionConverter == nullptr) {
         return(StatusCode::SUCCESS);
      }
      m_headerIterator = &m_poolCollectionConverter->selectAll();
      while (m_headerIterator == nullptr || m_headerIterator->next() == 0) { // empty collection
         if (m_poolCollectionConverter != nullptr) {
            m_poolCollectionConverter->disconnectDb().ignore();
            delete m_poolCollectionConverter; m_poolCollectionConverter = nullptr;
         }
         ++m_inputCollectionsIterator;
         m_poolCollectionConverter = getCollectionCnv();
         if (m_poolCollectionConverter != nullptr) {
            m_headerIterator = &m_poolCollectionConverter->selectAll();
         } else {
            break;
         }
      }
   }
   if (m_poolCollectionConverter == nullptr || m_headerIterator == nullptr) {
      return(StatusCode::SUCCESS);
   }
   const Token& headRef = m_refName.value().empty()?
      m_headerIterator->eventRef()
      : m_headerIterator->currentRow().tokenList()[m_refName.value() + "_ref"];
   const std::string fid = headRef.dbID().toString();
   const int tech = headRef.technology();
   ATH_MSG_VERBOSE("reinit(): First DataHeder Token=" << headRef.toString() );
 
   // Check if File is BS, for which Incident is thrown by SingleEventInputSvc
   if (tech != 0x00001000 && m_processMetadata.value() && !m_firedIncident) {
      FileIncident firstInputFileIncident(name(), "FirstInputFile", "FID:" + fid, fid);
      m_incidentSvc->fireIncident(firstInputFileIncident);
      m_firedIncident = true;
   }
   return(StatusCode::SUCCESS);
}

releaseContext()

StatusCode EventSelectorAthenaPool::releaseContext ( IEvtSelector::Context *&  ctxt ) const

overridevirtualinherited

Parameters

ctxt	[IN] current event context is released.

Definition at line 815 of file EventSelectorAthenaPool.cxx.

                                                                                {
   return(StatusCode::SUCCESS);
}

resetCriteria()

StatusCode EventSelectorAthenaPool::resetCriteria ( const std::string &  criteria, IEvtSelector::Context &  ctxt  ) const

overridevirtualinherited

Set a selection criteria.

Parameters

criteria	filter predicate (SQL-style WHERE clause)
ctxt	[IN] current event context.

Definition at line 819 of file EventSelectorAthenaPool.cxx.

                                      {
   return(StatusCode::SUCCESS);
}

rewind()

StatusCode EventSelectorAthenaPool::rewind ( IEvtSelector::Context &  ctxt ) const

overridevirtualinherited

Parameters

ctxt	[IN/OUT] current event context is rewound to first event.

Definition at line 782 of file EventSelectorAthenaPool.cxx.

                                                                          {
   ATH_CHECK(reinit());
   ctxt = EventContextAthenaPool(this);
   return(StatusCode::SUCCESS);
}

seek()

StatusCode DoubleEventSelectorAthenaPool::seek ( Context &  ctxt, int  evtNum  ) const

overridevirtual

Seek to a given event number.

Parameters

ctxt	[IN/OUT] current event context.
evtNum	[IN] The event number to which to seek.

Reimplemented from EventSelectorAthenaPool.

Definition at line 127 of file DoubleEventSelectorAthenaPool.cxx.

{
  ATH_MSG_DEBUG("DoubleEventSelectorAthenaPool::seek");
 
  ATH_CHECK(EventSelectorAthenaPool::seek(ctxt, evtNum));
  ATH_CHECK(m_secondarySelector->seek(ctxt, evtNum));
 
  return StatusCode::SUCCESS;
}

share()

StatusCode EventSelectorAthenaPool::share ( int  evtnum )

overridevirtualinherited

Request to share a given event number.

Parameters

evtnum

[IN] The event number to share.

Definition at line 969 of file EventSelectorAthenaPool.cxx.

                                                    {
   if (!m_eventStreamingTool.empty() && m_eventStreamingTool->isClient()) {
      StatusCode sc = m_eventStreamingTool->lockEvent(evtnum);
      while (sc.isRecoverable()) {
         usleep(1000);
         sc = m_eventStreamingTool->lockEvent(evtnum);
      }
// Send stop client and wait for restart
      if (sc.isFailure()) {
         if (m_athenaPoolCnvSvc->makeClient(0).isFailure()) {
            return(StatusCode::FAILURE);
         }
         sc = m_eventStreamingTool->lockEvent(evtnum);
         while (sc.isRecoverable() || sc.isFailure()) {
            usleep(1000);
            sc = m_eventStreamingTool->lockEvent(evtnum);
         }
//FIXME
         if (m_athenaPoolCnvSvc->makeClient(1).isFailure()) {
            return(StatusCode::FAILURE);
         }
      }
      return(sc);
   }
   return(StatusCode::FAILURE);
}

size()

int DoubleEventSelectorAthenaPool::size ( Context &  ctxt ) const

overridevirtual

Return the size of the collection.

Parameters

ctxt	[IN/OUT] current event context.

Reimplemented from EventSelectorAthenaPool.

Definition at line 138 of file DoubleEventSelectorAthenaPool.cxx.

{
  ATH_MSG_DEBUG("DoubleEventSelectorAthenaPool::size");
 
  int sz1 = EventSelectorAthenaPool::size(ctxt);
  int sz2 = m_secondarySelector->size(ctxt);
 
  if (sz2 < sz1) {
    ATH_MSG_WARNING("Fewer secondary input events than primary input events. Expect trouble!");
  }
 
  return sz1;
}

start()

StatusCode EventSelectorAthenaPool::start ( )

overridevirtualinherited

Definition at line 370 of file EventSelectorAthenaPool.cxx.

                                          {
   if (m_poolCollectionConverter != nullptr) {
      // Reset iterators and apply new query
      m_poolCollectionConverter->disconnectDb().ignore();
      delete m_poolCollectionConverter; m_poolCollectionConverter = nullptr;
   }
   m_inputCollectionsIterator = m_inputCollectionsProp.value().begin();
   m_curCollection = 0;
   if (!m_eventStreamingTool.empty() && m_eventStreamingTool->isClient()) {
      return(StatusCode::SUCCESS);
   }
   m_poolCollectionConverter = getCollectionCnv(true);
   if (m_poolCollectionConverter == nullptr) {
      ATH_MSG_INFO("No Events found in any Input Collections");
      m_inputCollectionsIterator = m_inputCollectionsProp.value().end();
      if (!m_inputCollectionsProp.value().empty()) {
         --m_inputCollectionsIterator; //leave iterator in state of last input file
      }
   } else {
      m_headerIterator = &m_poolCollectionConverter->executeQuery(/*m_query.value()*/);
   }
   m_evtCount = 0;
   delete m_endIter;
   m_endIter = nullptr;
   m_endIter = new EventContextAthenaPool(nullptr);
   return(StatusCode::SUCCESS);
}

stop()

StatusCode EventSelectorAthenaPool::stop ( )

overridevirtualinherited

Definition at line 398 of file EventSelectorAthenaPool.cxx.

                                         {
   if (!m_eventStreamingTool.empty() && m_eventStreamingTool->isClient()) {
      return(StatusCode::SUCCESS);
   }
   IEvtSelector::Context* ctxt(nullptr);
   if (!releaseContext(ctxt).isSuccess()) {
      ATH_MSG_WARNING("Cannot release context");
   }
   return(StatusCode::SUCCESS);
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/10]

PoolCollectionConverter* m_poolCollectionConverter EventSelectorAthenaPool::ATLAS_THREAD_SAFE {}

mutableprivateinherited

Definition at line 173 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [2/10]

pool::ICollectionCursor* m_headerIterator EventSelectorAthenaPool::ATLAS_THREAD_SAFE {}

mutableprivateinherited

Definition at line 174 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [3/10]

Guid m_guid EventSelectorAthenaPool::ATLAS_THREAD_SAFE {}

mutableprivateinherited

Definition at line 175 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [4/10]

std::map<SG::SourceID, int> m_activeEventsPerSource EventSelectorAthenaPool::ATLAS_THREAD_SAFE

mutableprivateinherited

Definition at line 176 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [5/10]

std::vector<std::string>::const_iterator m_inputCollectionsIterator EventSelectorAthenaPool::ATLAS_THREAD_SAFE

mutableprivateinherited

Definition at line 200 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [6/10]

bool m_inputCollectionsChanged EventSelectorAthenaPool::ATLAS_THREAD_SAFE

mutableprivateinherited

flag to notify the EvSel that the inputs were changed and reinit() needs to be called ASAP

Definition at line 203 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [7/10]

ToolHandleArray<IAthenaSelectorTool> m_helperTools EventSelectorAthenaPool::ATLAS_THREAD_SAFE {this}

mutableprivateinherited

HelperTools, vector of names of AlgTools that are executed by the EventSelector.

Definition at line 213 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [8/10]

std::vector<int> m_numEvt EventSelectorAthenaPool::ATLAS_THREAD_SAFE

mutableprivateinherited

Definition at line 236 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [9/10]

std::vector<int> m_firstEvt EventSelectorAthenaPool::ATLAS_THREAD_SAFE

mutableprivateinherited

Definition at line 237 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [10/10]

std::vector<std::pair<long,long> > m_skipEventRanges EventSelectorAthenaPool::ATLAS_THREAD_SAFE

mutableprivateinherited

Definition at line 244 of file EventSelectorAthenaPool.h.

m_athenaPoolCnvSvc

ServiceHandle<IAthenaPoolCnvSvc> EventSelectorAthenaPool::m_athenaPoolCnvSvc {this, "AthenaPoolCnvSvc", "AthenaPoolCnvSvc", ""}

privateinherited

Definition at line 178 of file EventSelectorAthenaPool.h.

m_attrListKey

Gaudi::Property<std::string> EventSelectorAthenaPool::m_attrListKey {this, "AttributeListKey", "Input", ""}

privateinherited

AttributeList SG key.

Definition at line 196 of file EventSelectorAthenaPool.h.

m_callLock

CallMutex EventSelectorAthenaPool::m_callLock

mutableprivateinherited

Definition at line 250 of file EventSelectorAthenaPool.h.

m_collectionTree

Gaudi::Property<std::string> EventSelectorAthenaPool::m_collectionTree {this, "CollectionTree", APRDefaults::TTreeNames::DataHeader, ""}

privateinherited

CollectionTree, prefix of the collection TTree: default = "POOLContainer".

Definition at line 189 of file EventSelectorAthenaPool.h.

m_collectionType

Gaudi::Property<std::string> EventSelectorAthenaPool::m_collectionType {this, "CollectionType", "ImplicitROOT", ""}

privateinherited

CollectionType, type of the collection: default = "ImplicitROOT".

Definition at line 187 of file EventSelectorAthenaPool.h.

m_connection

Gaudi::Property<std::string> EventSelectorAthenaPool::m_connection {this, "Connection", "", ""}

privateinherited

Connection, connection string.

Definition at line 192 of file EventSelectorAthenaPool.h.

m_counterTool

ToolHandle<IAthenaSelectorTool> EventSelectorAthenaPool::m_counterTool {this, "CounterTool", "", ""}

privateinherited

Definition at line 214 of file EventSelectorAthenaPool.h.

m_curCollection

std::atomic_long EventSelectorAthenaPool::m_curCollection {}

mutableprivateinherited

Definition at line 235 of file EventSelectorAthenaPool.h.

m_endIter

EventContextAthenaPool* EventSelectorAthenaPool::m_endIter {}

privateinherited

Definition at line 170 of file EventSelectorAthenaPool.h.

m_eventsPerLB

Gaudi::CheckedProperty<int> EventSelectorAthenaPool::m_eventsPerLB {this, "EventsPerLB", 1000, ""}

privateinherited

Definition at line 231 of file EventSelectorAthenaPool.h.

m_eventsPerRun

Gaudi::CheckedProperty<int> EventSelectorAthenaPool::m_eventsPerRun {this, "EventsPerRun", 1000000, ""}

privateinherited

Definition at line 229 of file EventSelectorAthenaPool.h.

m_eventStreamingTool

ToolHandle<IAthenaIPCTool> EventSelectorAthenaPool::m_eventStreamingTool {this, "SharedMemoryTool", "", ""}

privateinherited

Definition at line 215 of file EventSelectorAthenaPool.h.

m_evtCount

std::atomic_int EventSelectorAthenaPool::m_evtCount {}

mutableprivateinherited

Definition at line 246 of file EventSelectorAthenaPool.h.

m_firedIncident

std::atomic_bool EventSelectorAthenaPool::m_firedIncident {}

mutableprivateinherited

Definition at line 247 of file EventSelectorAthenaPool.h.

m_firstEventNo

Gaudi::CheckedProperty<int> EventSelectorAthenaPool::m_firstEventNo {this, "FirstEvent", 1, ""}

privateinherited

Definition at line 227 of file EventSelectorAthenaPool.h.

m_firstLBNo

Gaudi::CheckedProperty<int> EventSelectorAthenaPool::m_firstLBNo {this, "FirstLB", 0, ""}

privateinherited

Definition at line 230 of file EventSelectorAthenaPool.h.

m_incidentSvc

ServiceHandle<IIncidentSvc> EventSelectorAthenaPool::m_incidentSvc {this, "IncidentSvc", "IncidentSvc", ""}

privateinherited

Definition at line 179 of file EventSelectorAthenaPool.h.

m_initTimeStamp

Gaudi::CheckedProperty<int> EventSelectorAthenaPool::m_initTimeStamp {this, "InitialTimeStamp", 0, ""}

privateinherited

Definition at line 232 of file EventSelectorAthenaPool.h.

m_inputCollectionsProp

Gaudi::Property<std::vector<std::string> > EventSelectorAthenaPool::m_inputCollectionsProp {this, "InputCollections", {}, ""}

privateinherited

InputCollections, vector with names of the input collections.

Definition at line 199 of file EventSelectorAthenaPool.h.

m_isSecondary

Gaudi::Property<bool> EventSelectorAthenaPool::m_isSecondary {this, "IsSecondary", false, ""}

privateinherited

IsSecondary, know if this is an instance of secondary event selector.

Definition at line 183 of file EventSelectorAthenaPool.h.

m_keepInputFilesOpen

Gaudi::Property<bool> EventSelectorAthenaPool::m_keepInputFilesOpen {this, "KeepInputFilesOpen", false, ""}

privateinherited

KeepInputFilesOpen, boolean flag to keep files open after PoolCollection reaches end: default = false.

Needed for PilUp to run without PoolFileCatalog. Relies on POOL to close files when reaching DB_AGE_LIMIT.

Definition at line 210 of file EventSelectorAthenaPool.h.

m_makeStreamingToolClient

IntegerProperty EventSelectorAthenaPool::m_makeStreamingToolClient {this,"MakeStreamingToolClient",0}

privateinherited

Make this instance a Streaming Client during first iteration automatically.

Definition at line 217 of file EventSelectorAthenaPool.h.

m_oldRunNo

Gaudi::CheckedProperty<int> EventSelectorAthenaPool::m_oldRunNo {this, "OldRunNumber", 0, ""}

privateinherited

Definition at line 223 of file EventSelectorAthenaPool.h.

m_overrideRunNumber

Gaudi::Property<bool> EventSelectorAthenaPool::m_overrideRunNumber {this, "OverrideRunNumber", false, ""}

privateinherited

Definition at line 224 of file EventSelectorAthenaPool.h.

m_overrideRunNumberFromInput

Gaudi::Property<bool> EventSelectorAthenaPool::m_overrideRunNumberFromInput {this, "OverrideRunNumberFromInput", false, ""}

privateinherited

Definition at line 225 of file EventSelectorAthenaPool.h.

m_processMetadata

Gaudi::Property<bool> EventSelectorAthenaPool::m_processMetadata {this, "ProcessMetadata", true, ""}

privateinherited

ProcessMetadata, switch on firing of FileIncidents which will trigger processing of metadata: default = true.

Definition at line 185 of file EventSelectorAthenaPool.h.

m_query

Gaudi::Property<std::string> EventSelectorAthenaPool::m_query {this, "Query", "", ""}

privateinherited

Query string passed to APR when opening DataHeader container (kind of useless).

Definition at line 206 of file EventSelectorAthenaPool.h.

m_refName

Gaudi::Property<std::string> EventSelectorAthenaPool::m_refName {this, "RefName", "", ""}

privateinherited

RefName, attribute name.

Definition at line 194 of file EventSelectorAthenaPool.h.

m_runNo

Gaudi::CheckedProperty<int> EventSelectorAthenaPool::m_runNo {this, "RunNumber", 0, ""}

privateinherited

The following are included for compatibility with McEventSelector and are not really used.

However runNo, oldRunNo and overrideRunNumberFromInput are used to reset run number for simulated events, needed to use condition

Definition at line 222 of file EventSelectorAthenaPool.h.

m_secondaryAttrListSuffix

Gaudi::Property<std::string> DoubleEventSelectorAthenaPool::m_secondaryAttrListSuffix {this, "SecondaryAttrListSuffix", "secondary", ""}

private

Definition at line 67 of file DoubleEventSelectorAthenaPool.h.

m_secondaryByteStream

bool DoubleEventSelectorAthenaPool::m_secondaryByteStream {}

private

Definition at line 70 of file DoubleEventSelectorAthenaPool.h.

m_secondarySelector

ServiceHandle<ISecondaryEventSelector> DoubleEventSelectorAthenaPool::m_secondarySelector {this, "SecondaryEventSelector", "SecondaryEventSelector", ""}

private

Definition at line 65 of file DoubleEventSelectorAthenaPool.h.

m_skipEventRangesProp

Gaudi::Property<std::string> EventSelectorAthenaPool::m_skipEventRangesProp {this, "SkipEventRanges", {}, ""}

privateinherited

Skip Events - comma separated list of event to skip, ranges with '-': <start> - <end>

Definition at line 243 of file EventSelectorAthenaPool.h.

m_skipEvents

Gaudi::Property<int> EventSelectorAthenaPool::m_skipEvents {this, "SkipEvents", 0, ""}

privateinherited

SkipEvents, numbers of events to skip: default = 0.

Definition at line 240 of file EventSelectorAthenaPool.h.

m_skipEventSequenceProp

Gaudi::Property<std::vector<long> > EventSelectorAthenaPool::m_skipEventSequenceProp {this, "SkipEventSequence", {}, ""}

privateinherited

Definition at line 241 of file EventSelectorAthenaPool.h.

m_sourceID

SG::SlotSpecificObj<SG::SourceID> EventSelectorAthenaPool::m_sourceID

privateinherited

Definition at line 252 of file EventSelectorAthenaPool.h.

m_sourceID1

SG::SlotSpecificObj<SG::SourceID> DoubleEventSelectorAthenaPool::m_sourceID1

private

Definition at line 72 of file DoubleEventSelectorAthenaPool.h.

m_sourceID2

SG::SlotSpecificObj<SG::SourceID> DoubleEventSelectorAthenaPool::m_sourceID2

private

Definition at line 73 of file DoubleEventSelectorAthenaPool.h.

m_timeStampInterval

Gaudi::Property<int> EventSelectorAthenaPool::m_timeStampInterval {this, "TimeStampInterval", 0, ""}

privateinherited

Definition at line 233 of file EventSelectorAthenaPool.h.

---

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

• DoubleEventSelectorAthenaPool.h
• DoubleEventSelectorAthenaPool.cxx