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.
virtual	~DoubleEventSelectorAthenaPool ()
	Destructor.
virtual StatusCode	initialize () override
	Initialize function.
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.
virtual int	size (Context &ctxt) const override
	Return the size of the collection.
virtual void	handle (const Incident &incident) override
	Incident service handle listening for BeginProcessing and EndProcessing.
virtual StatusCode	start () override
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
virtual StatusCode	createContext (IEvtSelector::Context *&ctxt) const override
	create context
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.
virtual int	curEvent (const Context &ctxt) const override
	Return the current event number.
virtual StatusCode	io_reinit () override
	Callback method to reinitialize the internal state of the component for I/O purposes (e.g. upon fork(2)).
virtual StatusCode	io_finalize () override
	Callback method to finalize the internal state of the component for I/O purposes (e.g. before fork(2)).

Protected Member Functions
virtual StatusCode	nextHandleFileTransition (IEvtSelector::Context &ctxt) const override
	Handle file transition at the next iteration.
virtual StatusCode	nextWithSkip (IEvtSelector::Context &ctxt) const override
	Go to next event and skip if necessary.
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.
virtual bool	disconnectIfFinished (const SG::SourceID &fid) const override
	Disconnect DB if all events from the source FID were processed and the Selector moved to another file.

Private Types
typedef std::mutex	CallMutex

Private Member Functions
virtual StatusCode	recordAttributeList () const override
	Record AttributeList in StoreGate.
StoreGateSvc *	eventStore () const
	Return pointer to active event SG.
StatusCode	reinit () const
	Reinitialize the service when a fork() occurred/was-issued.
std::unique_ptr< pool::Collection >	getCollection (bool throwIncidents=false) const
	Return pointer to new Collection.
StatusCode	openCollection (std::string &inputCollection, std::unique_ptr< pool::Collection > &poolCollection, std::string *lastError=nullptr) const
	Open a collection by name.
void	disconnectCollection () const
	Disconnect current collection DB if open.
int	findEvent (int evtNum) const
	Search for event with number evtNum.
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 {}
std::unique_ptr< pool::Collection > m_poolCollection	ATLAS_THREAD_SAFE {}
std::string m_curCollectionName	ATLAS_THREAD_SAFE
std::unique_ptr< pool::CollectionCursor > m_headerIterator	ATLAS_THREAD_SAFE {}
Guid m_guid	ATLAS_THREAD_SAFE {}
std::map< SG::SourceID, int > m_activeEventsPerSource	ATLAS_THREAD_SAFE
std::optional< InputFileIncidentGuard > m_inputFileGuard	ATLAS_THREAD_SAFE
	RAII guard: guarantees a matching EndInputFile for every BeginInputFile.
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
ToolHandleArray< IAthenaSelectorTool > m_helperTools	ATLAS_THREAD_SAFE {this, "HelperTools", {}, ""}
	HelperTools, vector of names of AlgTools that are executed by the EventSelector.
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, "ConversionService", "AthenaPoolCnvSvc", ""}
ServiceHandle< IPoolSvc >	m_poolSvc {this, "PoolSvc", "PoolSvc", ""}
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.
Gaudi::Property< bool >	m_processMetadata {this, "ProcessMetadata", true, ""}
	ProcessMetadata, switch on firing of FileIncidents which will trigger processing of metadata: default = true.
std::string	m_attrListKey {"Input"}
	AttributeList SG key.
Gaudi::Property< std::vector< std::string > >	m_inputCollectionsProp {this, "InputCollections", {}, ""}
	InputCollections, vector with names of the input collections.
Gaudi::Property< bool >	m_keepInputFilesOpen {this, "KeepInputFilesOpen", false, ""}
	KeepInputFilesOpen, boolean flag to keep files open after PoolCollection reaches end: default = false.
ToolHandle< IAthenaSelectorTool >	m_counterTool {this, "CounterTool", "", ""}
Gaudi::CheckedProperty< uint32_t >	m_runNo {this, "RunNumber", 0, ""}
	The following are included for compatibility with McEventSelector and are not really used.
Gaudi::CheckedProperty< uint32_t >	m_oldRunNo {this, "OldRunNumber", 0, ""}
Gaudi::Property< bool >	m_overrideRunNumber {this, "OverrideRunNumber", false, ""}
Gaudi::Property< bool >	m_overrideRunNumberFromInput {this, "OverrideRunNumberFromInput", false, ""}
Gaudi::CheckedProperty< uint64_t >	m_firstEventNo {this, "FirstEvent", 1, ""}
Gaudi::CheckedProperty< uint64_t >	m_eventsPerRun {this, "EventsPerRun", 1000000, ""}
Gaudi::CheckedProperty< uint32_t >	m_firstLBNo {this, "FirstLB", 0, ""}
Gaudi::CheckedProperty< uint32_t >	m_eventsPerLB {this, "EventsPerLB", 1000, ""}
Gaudi::CheckedProperty< uint32_t >	m_initTimeStamp {this, "InitialTimeStamp", 0, ""}
Gaudi::Property< uint32_t >	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.
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>.
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 227 of file EventSelectorAthenaPool.h.

Constructor & Destructor Documentation

DoubleEventSelectorAthenaPool()

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

Standard Service Constructor.

Definition at line 23 of file DoubleEventSelectorAthenaPool.cxx.

  : EventSelectorAthenaPool(name, pSvcLocator)
{
}

~DoubleEventSelectorAthenaPool()

DoubleEventSelectorAthenaPool::~DoubleEventSelectorAthenaPool ( )

virtual

Destructor.

Definition at line 29 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 556 of file EventSelectorAthenaPool.cxx.

                                    {
   std::string tokenStr;
   SG::ReadHandle<AthenaAttributeList> attrList(m_attrListKey, eventStore()->name());
   if (attrList.isValid()) {
      try {
         tokenStr = (*attrList)["eventRef"].data<std::string>();
         ATH_MSG_DEBUG("found AthenaAttribute, name = eventRef = " << tokenStr);
      } catch (std::exception &e) {
         ATH_MSG_ERROR(e.what());
         return StatusCode::FAILURE;
      }
   } else {
      ATH_MSG_WARNING("Cannot find AthenaAttribute, key = " << m_attrListKey);
      tokenStr = m_headerIterator->eventRef().toString();
   }
   auto token = std::make_unique<Token>();
   token->fromString(tokenStr);
   m_incidentSvc->fireIncident(Incident(tokenStr, "ProcessEventAttributes"));
   iop = new TokenAddress(pool::POOL_StorageType.type(), ClassID_traits<DataHeader>::ID(), "", "EventSelector", IPoolSvc::kInputStream, std::move(token));
   return StatusCode::SUCCESS;
}

createContext()

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

overridevirtualinherited

create context

Definition at line 336 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 650 of file EventSelectorAthenaPool.cxx.

                                                             {
  return(m_evtCount);
}

disconnectCollection()

void EventSelectorAthenaPool::disconnectCollection ( ) const

privateinherited

Disconnect current collection DB if open.

Definition at line 722 of file EventSelectorAthenaPool.cxx.

                                                         {
   if (m_poolCollection) {
      if (!m_curCollectionName.empty()) {
         m_poolSvc->disconnectDb(m_curCollectionName).ignore();
         m_curCollectionName.clear();
      }
      m_poolCollection.reset();
   }
}

disconnectIfFinished()

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

overrideprotectedvirtualinherited

Disconnect DB if all events from the source FID were processed and the Selector moved to another file.

Definition at line 912 of file EventSelectorAthenaPool.cxx.

{
   if( m_activeEventsPerSource.find(fid) != m_activeEventsPerSource.end() 
           && m_activeEventsPerSource[fid] <= 0 && m_guid != fid ) {
      // Explicitly disconnect file corresponding to old FID to release memory.
      // EndInputFile is handled by the InputFileIncidentGuard.
      if( !m_keepInputFilesOpen.value() ) {
         ATH_MSG_INFO("Disconnecting input sourceID: " << fid );
         m_poolSvc->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 69 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 790 of file EventSelectorAthenaPool.cxx.

{
   const auto& row = m_headerIterator->currentRow();
   attrList->extend( row.tokenName() + suffix, "string" );
   (*attrList)[ row.tokenName() + suffix ].data<std::string>() = row.token().toString();
   ATH_MSG_DEBUG("record AthenaAttribute, name = " << row.tokenName() + suffix << " = " << row.token().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 318 of file EventSelectorAthenaPool.cxx.

                                             {
   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;
   m_poolCollection.reset();
   m_curCollectionName.clear();
   // 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 658 of file EventSelectorAthenaPool.cxx.

                                                       {
   for (std::size_t i = 0, imax = m_numEvt.size(); i < imax; i++) {
      if (m_numEvt[i] == -1) {
         std::string collName = m_inputCollectionsProp.value()[i];
         std::string lastError;
         std::unique_ptr<pool::Collection> coll;
         StatusCode status = openCollection(collName, coll, &lastError);
         if (!status.isSuccess()) {
            break;
         }
         int collection_size = 0;
         if (coll) {
            std::unique_ptr<pool::CollectionCursor> hi = coll->cursor();
            collection_size = hi->size();
         }
         else {
            ATH_MSG_ERROR( lastError );
         }
         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);
}

getCollection()

std::unique_ptr< pool::Collection > EventSelectorAthenaPool::getCollection ( bool throwIncidents = false ) const

privateinherited

Return pointer to new Collection.

Definition at line 733 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.");
      std::string collName = *m_inputCollectionsIterator;
      std::unique_ptr<pool::Collection> coll;
      StatusCode status = openCollection(collName, coll);
      if (!status.isSuccess()) {
         if (!status.isRecoverable()) {
            ATH_MSG_ERROR("Unable to initialize Collection.");
            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 (!coll) {
            ATH_MSG_DEBUG("No events found in: " << *m_inputCollectionsIterator << " skipped!!!");
            if (throwIncidents && m_processMetadata.value()) {
               // Scoped guard: fires BeginInputFile now, EndInputFile at scope exit
               auto guard = InputFileIncidentGuard::begin(*m_incidentSvc, name(),
                              *m_inputCollectionsIterator, {},
                              "eventless " + *m_inputCollectionsIterator);
            }
            m_poolSvc->disconnectDb(*m_inputCollectionsIterator).ignore();
            ++m_inputCollectionsIterator;
         } else {
            m_curCollectionName = collName;
            return coll;
         }
      }
   }
   return nullptr;
}

handle()

void DoubleEventSelectorAthenaPool::handle ( const Incident & incident )

overridevirtual

Incident service handle listening for BeginProcessing and EndProcessing.

Reimplemented from EventSelectorAthenaPool.

Definition at line 191 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 32 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 60 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 857 of file EventSelectorAthenaPool.cxx.

                                                {
   ATH_MSG_INFO("I/O finalization...");
   // Fire EndInputFile before disconnecting — file data is still accessible here
   m_inputFileGuard.reset();
   disconnectCollection();
   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 816 of file EventSelectorAthenaPool.cxx.

                                              {
   ATH_MSG_INFO("I/O reinitialization...");
   disconnectCollection();
   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;
   }
   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;
      }
      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 542 of file EventSelectorAthenaPool.cxx.

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

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 45 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 105 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 414 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.
         m_poolCollection.reset();
 
         // Fire EndInputFile while data is still accessible, then disconnect
         m_inputFileGuard.reset();
         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.
            if (m_inputCollectionsIterator == m_inputCollectionsProp.value().end()) {
              m_poolCollection = nullptr;
            }
            else {
              ++m_inputCollectionsIterator;
              // Create Collection for input file
              m_poolCollection = getCollection(true);
            }
            if (!m_poolCollection) {
               // 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_poolCollection->cursor();
 
            // Return RECOVERABLE to mark we should still continue
            return StatusCode::RECOVERABLE;
         }
      }
   }
   const Token& headRef = m_headerIterator->eventRef();
   const Guid guid = headRef.dbID();
   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();
         // EndInputFile is fired by the guard transition() below; just disconnect here
         disconnectIfFinished( old_guid );
      }
      m_guid = guid;
      m_activeEventsPerSource[guid.toString()] = 0;
      if (!m_athenaPoolCnvSvc->setInputAttributes(*m_inputCollectionsIterator).isSuccess()) {
         ATH_MSG_ERROR("Failed to set input attributes.");
         return StatusCode::FAILURE;
      }
      if(m_processMetadata.value()) {
         InputFileIncidentGuard::transition(m_inputFileGuard, *m_incidentSvc, name(),
                                            *m_inputCollectionsIterator, m_guid.toString(),
                                            /*endFileName=*/{});
      }
   }  // 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 489 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;
}

openCollection()

StatusCode EventSelectorAthenaPool::openCollection ( std::string & inputCollection, std::unique_ptr< pool::Collection > & poolCollection, std::string * lastError = nullptr ) const

privateinherited

Open a collection by name.

Definition at line 697 of file EventSelectorAthenaPool.cxx.

                                                                               {
   if (!inputCollection.starts_with("PFN:")
       && !inputCollection.starts_with("LFN:")
       && !inputCollection.starts_with("FID:")) {
      inputCollection = std::format("PFN:{}", inputCollection);
   }
   StatusCode sc = m_poolSvc->connectCollection(inputCollection, "Input", IPoolSvc::kInputStream);
   try {
      auto fileDescr = m_poolSvc->getInputFileDescriptor(IPoolSvc::kInputStream, inputCollection);
      poolCollection = std::make_unique<pool::Collection>(fileDescr);
      if (lastError) lastError->clear();
   } catch (const std::exception &e) {
      if (lastError) {
         *lastError = std::format("Failed to open collection '{}': {}", inputCollection, e.what());
      }
      poolCollection.reset();
   }
   if (sc.isRecoverable() || poolCollection == nullptr) {
      return m_poolSvc->checkCollection(inputCollection, IPoolSvc::kInputStream, poolCollection == nullptr);
   }
   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 527 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 532 of file EventSelectorAthenaPool.cxx.

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

recordAttributeList()

StatusCode DoubleEventSelectorAthenaPool::recordAttributeList ( ) const

overrideprivatevirtual

Record AttributeList in StoreGate.

Reimplemented from EventSelectorAthenaPool.

Definition at line 148 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, eventStore()->name());
  ATH_CHECK(wh.record(std::move(athAttrList)));
 
  return StatusCode::SUCCESS;
}

reinit()

StatusCode EventSelectorAthenaPool::reinit ( ) const

privateinherited

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

Definition at line 181 of file EventSelectorAthenaPool.cxx.

                                                 {
   ATH_MSG_DEBUG("reinitialization...");
 
   // reset markers
   m_numEvt.resize(m_inputCollectionsProp.value().size(), -1);
   m_firstEvt.resize(m_inputCollectionsProp.value().size(), -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;
   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;
   }
 
   // Create an m_poolCollection to read the objects in
   m_poolCollection = getCollection();
   if (!m_poolCollection) {
      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_firedIncident && !m_inputCollectionsProp.value().empty() ) {
            FileIncident firstInputFileIncident(name(), "FirstInputFile", *m_inputCollectionsIterator);
            m_incidentSvc->fireIncident(firstInputFileIncident);
            m_firedIncident = true;
         }
      }
      return StatusCode::SUCCESS;
   }
   // Get DataHeader iterator
   try {
      m_headerIterator = m_poolCollection->cursor();
   } catch (std::exception &e) {
      ATH_MSG_FATAL("Cannot open input collection - check data/software version.");
      ATH_MSG_ERROR(e.what());
      return StatusCode::FAILURE;
   }
   while (m_headerIterator == nullptr || m_headerIterator->next() == 0) { // no selected events
      disconnectCollection();
      if (m_inputCollectionsIterator == m_inputCollectionsProp.value().end()) {
        m_poolCollection = nullptr;
      }
      else {
        ++m_inputCollectionsIterator;
        m_poolCollection = getCollection();
      }
      if (m_poolCollection) {
         m_headerIterator = m_poolCollection->cursor();
      } else {
         break;
      }
   }
   if (!m_poolCollection || m_headerIterator == nullptr) { // no event selected in any collection
      m_inputCollectionsIterator = m_inputCollectionsProp.value().begin();
      m_curCollection = 0;
      m_poolCollection = getCollection();
      if (!m_poolCollection) {
         return StatusCode::SUCCESS;
      }
      m_headerIterator = m_poolCollection->cursor();
      while (m_headerIterator == nullptr || m_headerIterator->next() == 0) { // empty collection
         disconnectCollection();
         ++m_inputCollectionsIterator;
         m_poolCollection = getCollection();
         if (m_poolCollection) {
            m_headerIterator = m_poolCollection->cursor();
         } else {
            break;
         }
      }
   }
   if (!m_poolCollection || m_headerIterator == nullptr) {
      return StatusCode::SUCCESS;
   }
   const Token& headRef = m_headerIterator->eventRef();
   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 579 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 583 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 550 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 122 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;
}

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 133 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 284 of file EventSelectorAthenaPool.cxx.

                                          {
   disconnectCollection();
   m_inputCollectionsIterator = m_inputCollectionsProp.value().begin();
   m_curCollection = 0;
   m_poolCollection = getCollection(true);
   if (!m_poolCollection) {
      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_poolCollection->cursor();
   }
   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 305 of file EventSelectorAthenaPool.cxx.

                                         {
   // Fire EndInputFile for any file still open (the event loop may end
   // before the file is fully read).
   m_inputFileGuard.reset();
 
   IEvtSelector::Context* ctxt(nullptr);
   if (!releaseContext(ctxt).isSuccess()) {
      ATH_MSG_WARNING("Cannot release context");
   }
   return StatusCode::SUCCESS;
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/12]

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

mutableprivateinherited

Definition at line 222 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [2/12]

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

mutableprivateinherited

Definition at line 215 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [3/12]

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

mutableprivateinherited

Definition at line 214 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [4/12]

ToolHandleArray<IAthenaSelectorTool> m_helperTools EventSelectorAthenaPool::ATLAS_THREAD_SAFE {this, "HelperTools", {}, ""}

mutableprivateinherited

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

Definition at line 194 of file EventSelectorAthenaPool.h.

{this, "HelperTools", {}, ""};

ATLAS_THREAD_SAFE [5/12]

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 187 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [6/12]

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

mutableprivateinherited

Definition at line 184 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [7/12]

std::optional<InputFileIncidentGuard> m_inputFileGuard EventSelectorAthenaPool::ATLAS_THREAD_SAFE

mutableprivateinherited

RAII guard: guarantees a matching EndInputFile for every BeginInputFile.

Definition at line 167 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [8/12]

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

mutableprivateinherited

Definition at line 165 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [9/12]

Guid m_guid EventSelectorAthenaPool::ATLAS_THREAD_SAFE {}

mutableprivateinherited

Definition at line 164 of file EventSelectorAthenaPool.h.

{};

ATLAS_THREAD_SAFE [10/12]

std::unique_ptr<pool::CollectionCursor> m_headerIterator EventSelectorAthenaPool::ATLAS_THREAD_SAFE {}

mutableprivateinherited

Definition at line 163 of file EventSelectorAthenaPool.h.

{};

ATLAS_THREAD_SAFE [11/12]

std::string m_curCollectionName EventSelectorAthenaPool::ATLAS_THREAD_SAFE

mutableprivateinherited

Definition at line 162 of file EventSelectorAthenaPool.h.

ATLAS_THREAD_SAFE [12/12]

std::unique_ptr<pool::Collection> m_poolCollection EventSelectorAthenaPool::ATLAS_THREAD_SAFE {}

mutableprivateinherited

Definition at line 161 of file EventSelectorAthenaPool.h.

{};

m_athenaPoolCnvSvc

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

privateinherited

Definition at line 169 of file EventSelectorAthenaPool.h.

{this, "ConversionService", "AthenaPoolCnvSvc", ""};

m_attrListKey

std::string EventSelectorAthenaPool::m_attrListKey {"Input"}

privateinherited

AttributeList SG key.

Definition at line 180 of file EventSelectorAthenaPool.h.

{"Input"};

m_callLock

CallMutex EventSelectorAthenaPool::m_callLock

mutableprivateinherited

Definition at line 228 of file EventSelectorAthenaPool.h.

m_counterTool

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

privateinherited

Definition at line 195 of file EventSelectorAthenaPool.h.

{this, "CounterTool", "", ""};

m_curCollection

std::atomic_long EventSelectorAthenaPool::m_curCollection {}

mutableprivateinherited

Definition at line 213 of file EventSelectorAthenaPool.h.

{};

m_endIter

EventContextAthenaPool* EventSelectorAthenaPool::m_endIter {}

privateinherited

Definition at line 160 of file EventSelectorAthenaPool.h.

{};

m_eventsPerLB

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

privateinherited

Definition at line 209 of file EventSelectorAthenaPool.h.

{this, "EventsPerLB", 1000, ""};

m_eventsPerRun

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

privateinherited

Definition at line 207 of file EventSelectorAthenaPool.h.

{this, "EventsPerRun", 1000000, ""};

m_evtCount

std::atomic_int EventSelectorAthenaPool::m_evtCount {}

mutableprivateinherited

Definition at line 224 of file EventSelectorAthenaPool.h.

{}; // internal count of events

m_firedIncident

std::atomic_bool EventSelectorAthenaPool::m_firedIncident {}

mutableprivateinherited

Definition at line 225 of file EventSelectorAthenaPool.h.

{};

m_firstEventNo

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

privateinherited

Definition at line 205 of file EventSelectorAthenaPool.h.

{this, "FirstEvent", 1, ""};

m_firstLBNo

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

privateinherited

Definition at line 208 of file EventSelectorAthenaPool.h.

{this, "FirstLB", 0, ""};

m_incidentSvc

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

privateinherited

Definition at line 171 of file EventSelectorAthenaPool.h.

{this, "IncidentSvc", "IncidentSvc", ""};

m_initTimeStamp

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

privateinherited

Definition at line 210 of file EventSelectorAthenaPool.h.

{this, "InitialTimeStamp", 0, ""};

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 183 of file EventSelectorAthenaPool.h.

{this, "InputCollections", {}, ""};

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 175 of file EventSelectorAthenaPool.h.

{this, "IsSecondary", false, ""};

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 191 of file EventSelectorAthenaPool.h.

{this, "KeepInputFilesOpen", false, ""};

m_oldRunNo

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

privateinherited

Definition at line 201 of file EventSelectorAthenaPool.h.

{this, "OldRunNumber", 0, ""};

m_overrideRunNumber

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

privateinherited

Definition at line 202 of file EventSelectorAthenaPool.h.

{this, "OverrideRunNumber", false, ""};

m_overrideRunNumberFromInput

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

privateinherited

Definition at line 203 of file EventSelectorAthenaPool.h.

{this, "OverrideRunNumberFromInput", false, ""};

m_poolSvc

ServiceHandle<IPoolSvc> EventSelectorAthenaPool::m_poolSvc {this, "PoolSvc", "PoolSvc", ""}

privateinherited

Definition at line 170 of file EventSelectorAthenaPool.h.

{this, "PoolSvc", "PoolSvc", ""};

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 177 of file EventSelectorAthenaPool.h.

{this, "ProcessMetadata", true, ""};

m_runNo

Gaudi::CheckedProperty<uint32_t> 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 200 of file EventSelectorAthenaPool.h.

{this, "RunNumber", 0, ""};

m_secondaryAttrListSuffix

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

private

Definition at line 67 of file DoubleEventSelectorAthenaPool.h.

{this, "SecondaryAttrListSuffix", "secondary", ""};

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.

{this, "SecondaryEventSelector", "SecondaryEventSelector", ""};

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 221 of file EventSelectorAthenaPool.h.

{this, "SkipEventRanges", {}, ""};

m_skipEvents

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

privateinherited

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

Definition at line 218 of file EventSelectorAthenaPool.h.

{this, "SkipEvents", 0, ""};

m_skipEventSequenceProp

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

privateinherited

Definition at line 219 of file EventSelectorAthenaPool.h.

{this, "SkipEventSequence", {}, ""};

m_sourceID

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

privateinherited

Definition at line 230 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<uint32_t> EventSelectorAthenaPool::m_timeStampInterval {this, "TimeStampInterval", 0, ""}

privateinherited

Definition at line 211 of file EventSelectorAthenaPool.h.

{this, "TimeStampInterval", 0, ""};

---

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

• DoubleEventSelectorAthenaPool.h
• DoubleEventSelectorAthenaPool.cxx