EventSelectorByteStream Class Reference

concrete implementation of IEvtSelector for ByteStream More...

#include <EventSelectorByteStream.h>

Inheritance diagram for EventSelectorByteStream:

Collaboration diagram for EventSelectorByteStream:

Public Member Functions
	EventSelectorByteStream (const std::string &name, ISvcLocator *svcloc)
	Standard Constructor.
virtual	~EventSelectorByteStream ()
	Standard Destructor.
virtual StatusCode	initialize () override
	Implementation of Service base class methods.
virtual StatusCode	start () override
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
virtual StatusCode	createContext (Context *&it) const override
	create context
virtual StatusCode	next (Context &it) const override
virtual StatusCode	next (Context &it, int jump) const override
virtual StatusCode	previous (Context &it) const override
virtual StatusCode	previous (Context &it, int jump) const override
virtual StatusCode	last (Context &it) const override
virtual StatusCode	rewind (Context &it) const override
virtual StatusCode	createAddress (const Context &it, IOpaqueAddress *&iop) const override
virtual StatusCode	releaseContext (Context *&it) const override
virtual StatusCode	resetCriteria (const std::string &criteria, Context &context) const override
	Set a selection criteria.
virtual StatusCode	seek (Context &, int evtnum) const override
	Seek to a given event number.
virtual int	curEvent (const Context &it) const override
	Return the current event number.
virtual int	size (Context &it) const override
	Always returns -1.
virtual StatusCode	makeServer (int num) override
	Make this a server.
virtual StatusCode	makeClient (int num) override
	Make this a client.
virtual StatusCode	share (int evtnum) override
	Request to share a given event number.
virtual StatusCode	readEvent (int maxevt) override
	Read the next maxevt events.
virtual StatusCode	io_reinit () override
	Callback method to reinitialize the internal state of the component for I/O purposes (e.g. upon fork(2)).

Protected Types
using	mutex_t = std::recursive_mutex
using	lock_t = std::lock_guard<mutex_t>

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	recordAttributeList () const override
	Record AttributeList in StoreGate.
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

Private Member Functions
StatusCode	nextImpl (Context &it, lock_t &lock) const
StatusCode	nextImpl (Context &it, int jump, lock_t &lock) const
StatusCode	previousImpl (Context &it, lock_t &lock) const
StatusCode	previousImpl (Context &it, int jump, lock_t &lock) const
StatusCode	nextHandleFileTransitionImpl (IEvtSelector::Context &ctxt, lock_t &lock) const
StatusCode	nextWithSkipImpl (IEvtSelector::Context &ctxt, lock_t &lock) const
StatusCode	recordAttributeListImpl (lock_t &lock) const
StatusCode	fillAttributeListImpl (coral::AttributeList *attrList, const std::string &suffix, bool copySource, lock_t &lock) const
StatusCode	reinit (lock_t &lock)
	Reinitialize the service when a fork() occurred/was-issued.
StatusCode	openNewRun (lock_t &lock) const
void	nextFile (lock_t &lock) const
int	findEvent (int evtNum, lock_t &lock) const
	Search for event with number evtNum.
StoreGateSvc *	eventStore () const
void	inputCollectionsHandler (Gaudi::Details::PropertyBase &)

Private Attributes
mutex_t	m_mutex
int m_fileCount	ATLAS_THREAD_SAFE = 0
	number of files to process.
std::vector< int > m_numEvt	ATLAS_THREAD_SAFE
std::vector< int > m_firstEvt	ATLAS_THREAD_SAFE
std::vector< std::string >::const_iterator m_inputCollectionsIterator	ATLAS_THREAD_SAFE
std::vector< long > m_skipEventSequence	ATLAS_THREAD_SAFE
long m_NumEvents	ATLAS_THREAD_SAFE = 0
ToolHandle< IAthenaIPCTool > m_eventStreamingTool	ATLAS_THREAD_SAFE {this, "SharedMemoryTool", "", ""}
Gaudi::Property< bool >	m_isSecondary {this, "IsSecondary", false, ""}
	IsSecondary, know if this is an instance of secondary event selector.
Gaudi::Property< std::string >	m_eventSourceName {this, "ByteStreamInputSvc", "", ""}
Gaudi::Property< bool >	m_procBadEvent {this, "ProcessBadEvent", false, ""}
	process bad events, which fail check_tree().
Gaudi::Property< int >	m_maxBadEvts {this, "MaxBadEvents", -1, ""}
	number of bad events allowed before quitting.
EventContextByteStream *	m_beginIter {}
EventContextByteStream *	m_endIter {}
SmartIF< IByteStreamInputSvc >	m_eventSource
Gaudi::Property< std::vector< std::string > >	m_inputCollectionsProp {this, "Input", {}, ""}
ServiceHandle< IIncidentSvc >	m_incidentSvc {this, "IncidentSvc", "IncidentSvc", ""}
Gaudi::Property< long >	m_skipEvents {this, "SkipEvents", 0, ""}
Gaudi::Property< std::vector< long > >	m_skipEventSequenceProp {this, "SkipEventSequence", {}, ""}
bool	m_firstFileFired {}
std::optional< InputFileIncidentGuard > m_inputFileGuard	ATLAS_THREAD_SAFE
	RAII guard: guarantees a matching EndInputFile for every BeginInputFile.
ToolHandleArray< IAthenaSelectorTool >	m_helperTools {this, "HelperTools", {}, "Helper tools executed by EventSelector"}
	HelperTools, vector of names of AlgTools that are executed by the EventSelector.
ToolHandle< IAthenaSelectorTool >	m_counterTool {this, "CounterTool", "", ""}
Gaudi::Property< bool >	m_overrideRunNumber {this, "OverrideRunNumber", false, ""}
	The following are included for compatibility with McEventSelector and are not really used.
Gaudi::Property< bool >	m_filebased {this, "FileBased", true, ""}
Gaudi::CheckedProperty< uint32_t >	m_runNo {this, "RunNumber", 0, ""}
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, ""}

Detailed Description

concrete implementation of IEvtSelector for ByteStream

An event selector service that steps through Event Filter packed raw events by use of an event source object and an iterator object called EventIteratorByteStream. The type of event source is specified at run time. It

can be a single file, a set of files or the network.

Definition at line 44 of file EventSelectorByteStream.h.

Member Typedef Documentation

lock_t

using EventSelectorByteStream::lock_t = std::lock_guard<mutex_t>

protected

Definition at line 129 of file EventSelectorByteStream.h.

mutex_t

using EventSelectorByteStream::mutex_t = std::recursive_mutex

protected

Definition at line 128 of file EventSelectorByteStream.h.

Constructor & Destructor Documentation

EventSelectorByteStream()

EventSelectorByteStream::EventSelectorByteStream	(	const std::string &	name,
		ISvcLocator *	svcloc )

Standard Constructor.

Definition at line 43 of file EventSelectorByteStream.cxx.

    : base_class(name, svcloc) {
  // RunNumber, OldRunNumber and OverrideRunNumberFromInput are used
  // to override the run number coming in on the input stream
  m_runNo.verifier().setLower(0);
  // The following properties are only for compatibility with
  // McEventSelector and are not really used anywhere
  // TODO(berghaus): validate if those are even used
  m_eventsPerRun.verifier().setLower(0);
  m_firstEventNo.verifier().setLower(1);
  m_firstLBNo.verifier().setLower(0);
  m_eventsPerLB.verifier().setLower(0);
  m_initTimeStamp.verifier().setLower(0);
 
  m_inputCollectionsProp.declareUpdateHandler(
      &EventSelectorByteStream::inputCollectionsHandler, this);
}

~EventSelectorByteStream()

EventSelectorByteStream::~EventSelectorByteStream ( )

virtual

Standard Destructor.

Definition at line 72 of file EventSelectorByteStream.cxx.

                                                  {
}

Member Function Documentation

createAddress()

StatusCode EventSelectorByteStream::createAddress ( const Context & it, IOpaqueAddress *& iop ) const

overridevirtual

Parameters

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

Definition at line 964 of file EventSelectorByteStream.cxx.

                                            {
   SG::DataProxy* proxy = eventStore()->proxy(ClassID_traits<DataHeader>::ID(),"ByteStreamDataHeader");
   if (proxy !=0) {
     iop = proxy->address();
     return StatusCode::SUCCESS;
   } else {
     iop = 0;
     return StatusCode::FAILURE;
   }
}

createContext()

StatusCode EventSelectorByteStream::createContext ( Context *& it ) const

overridevirtual

create context

Definition at line 297 of file EventSelectorByteStream.cxx.

                                                                                {
   it = new EventContextByteStream(this);
   return StatusCode::SUCCESS;
}

curEvent()

int EventSelectorByteStream::curEvent ( const Context & it ) const

overridevirtual

Return the current event number.

Parameters

it	[IN/OUT] current event context.

Definition at line 875 of file EventSelectorByteStream.cxx.

                                                             {
   // event counter in IEvtSelectorSeek interface
   lock_t lock (m_mutex);
   return int(m_NumEvents);
}

disconnectIfFinished()

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

overrideprotectedvirtual

Definition at line 1019 of file EventSelectorByteStream.cxx.

{
   return true;
}

eventStore()

StoreGateSvc * EventSelectorByteStream::eventStore ( ) const

private

Definition at line 78 of file EventSelectorByteStream.cxx.

                                          {
   return StoreGateSvc::currentStoreGate();
}

fillAttributeList()

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

overrideprotectedvirtual

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

Definition at line 741 of file EventSelectorByteStream.cxx.

{
  lock_t lock (m_mutex);
  return fillAttributeListImpl (attrList, suffix, copySource, lock);
}

fillAttributeListImpl()

StatusCode EventSelectorByteStream::fillAttributeListImpl ( coral::AttributeList * attrList, const std::string & suffix, bool copySource, lock_t & lock ) const

private

Definition at line 746 of file EventSelectorByteStream.cxx.

{
   attrList->extend("RunNumber"   + suffix, "unsigned int");
   attrList->extend("EventNumber" + suffix, "unsigned long long");
   attrList->extend("LumiBlockN"  + suffix, "unsigned int");
   attrList->extend("BunchId"     + suffix, "unsigned int");
   attrList->extend("EventTime"        + suffix, "unsigned int");
   attrList->extend("EventTimeNanoSec" + suffix, "unsigned int");
 
   // fill attribute list
   const RawEvent* event = m_eventSource->currentEvent();
 
   (*attrList)["RunNumber" + suffix].data<unsigned int>() = event->run_no();
   if (event->version() < 0x03010000) {
      (*attrList)["EventNumber" + suffix].data<unsigned long long>() = event->lvl1_id();
   } else {
      (*attrList)["EventNumber" + suffix].data<unsigned long long>() = event->global_id();
   }
   (*attrList)["LumiBlockN" + suffix].data<unsigned int>() = event->lumi_block();
   (*attrList)["BunchId" + suffix].data<unsigned int>() = event->bc_id();
 
   unsigned int bc_time_sec = event->bc_time_seconds();
   unsigned int bc_time_ns  = event->bc_time_nanoseconds();
   // bc_time_ns should be lt 1e9.
   if (bc_time_ns > 1000000000) {
      // round it off to 1e9
      ATH_MSG_WARNING(" bc_time nanosecond number larger than 1e9, it is " << bc_time_ns << ", reset it to 1 sec");
      bc_time_ns = 1000000000;
   }
   (*attrList)["EventTime" + suffix].data<unsigned int>() = bc_time_sec;
   (*attrList)["EventTimeNanoSec" + suffix].data<unsigned int>() = bc_time_ns;
 
   const OFFLINE_FRAGMENTS_NAMESPACE::DataType* buffer;
 
   event->status(buffer);
   attrList->extend("TriggerStatus" + suffix, "unsigned int");
   (*attrList)["TriggerStatus" + suffix].data<unsigned int>() = *buffer;
 
   attrList->extend("ExtendedL1ID"  + suffix, "unsigned int");
   attrList->extend("L1TriggerType" + suffix, "unsigned int");
   (*attrList)["ExtendedL1ID" + suffix].data<unsigned int>() = event->lvl1_id();
   (*attrList)["L1TriggerType" + suffix].data<unsigned int>() = event->lvl1_trigger_type();
 
   // Grab L1 words
   event->lvl1_trigger_info(buffer);
   for (uint32_t iT1 = 0; iT1 < event->nlvl1_trigger_info(); ++iT1) {
      std::stringstream name;
      name << "L1TriggerInfo_" << iT1;
      attrList->extend(name.str() + suffix, "unsigned int");
      (*attrList)[name.str() + suffix].data<unsigned int>() = *buffer;
      ++buffer;
   }
 
   // Grab L2 words
   event->lvl2_trigger_info(buffer);
   for (uint32_t iT1 = 0; iT1 < event->nlvl2_trigger_info(); ++iT1) {
      if (*buffer != 0) {
         std::stringstream name;
         name << "L2TriggerInfo_" << iT1;
         attrList->extend(name.str() + suffix, "unsigned int");
         (*attrList)[name.str() + suffix].data<unsigned int>() = *buffer;
      }
      ++buffer;
   }
 
   // Grab EF words
   event->event_filter_info(buffer);
   for (uint32_t iT1 = 0; iT1 < event->nevent_filter_info(); ++iT1) {
      if (*buffer != 0) {
         std::stringstream name;
         name << "EFTriggerInfo_" << iT1;
         attrList->extend(name.str() + suffix, "unsigned int");
         (*attrList)[name.str() + suffix].data<unsigned int>() = *buffer;
      }
      ++buffer;
   }
 
   // Grab stream tags
   event->stream_tag(buffer);
   std::vector<eformat::helper::StreamTag> onl_streamTags;
   eformat::helper::decode(event->nstream_tag(), buffer, onl_streamTags);
   for (std::vector<eformat::helper::StreamTag>::const_iterator itS = onl_streamTags.begin(),
      itSE = onl_streamTags.end(); itS != itSE; ++itS) {
      attrList->extend(itS->name + suffix, stringTypeStr);
      (*attrList)[itS->name + suffix].data<std::string>() = itS->type;
   }
 
   return StatusCode::SUCCESS;
}

finalize()

StatusCode EventSelectorByteStream::finalize ( )

overridevirtual

Definition at line 225 of file EventSelectorByteStream.cxx.

                                             {
   if (!m_counterTool.empty()) {
      if (!m_counterTool->preFinalize().isSuccess()) {
         ATH_MSG_WARNING("Failed to preFinalize() CounterTool");
      }
   }
   for (ToolHandle<IAthenaSelectorTool>& tool : m_helperTools) {
      if (!tool->preFinalize().isSuccess()) {
         ATH_MSG_WARNING("Failed to preFinalize() " << tool->name());
      }
   }
   delete m_beginIter; m_beginIter = nullptr;
   delete m_endIter; m_endIter = nullptr;
   if (m_eventSource) m_eventSource->release();
   // Finalize the Service base class.
   return AthService::finalize();
}

findEvent()

int EventSelectorByteStream::findEvent ( int evtNum, lock_t & lock ) const

private

Search for event with number evtNum.

Definition at line 838 of file EventSelectorByteStream.cxx.

                                                                  {
   // Loop over file event counts
   for (size_t i = 0; i < m_inputCollectionsProp.value().size(); i++) {
      if (m_inputCollectionsProp.value().size() != m_numEvt.size()) {
         ATH_MSG_ERROR("vector size incompatibility");
         break;
      }
      // if file not opened yet, check it
      if (m_numEvt[i] == -1) {
         std::string fileName = m_inputCollectionsProp.value()[i];
         auto nevguid = m_eventSource->getBlockIterator(fileName);
         long nev = nevguid.first;
         // if failure on file open, exit
         if (nev==-1) {
            break;
         }
         // set initial event counter for that file
         if (i > 0) {
            m_firstEvt[i] = m_firstEvt[i - 1] + m_numEvt[i - 1];
         } else {
            m_firstEvt[i] = 0;
         }
         // log number of events in that file
         m_numEvt[i] = nev;
      }
      // if sought event is in this file, then return the index of that file
      if (evtNum >= m_firstEvt[i] && evtNum < m_firstEvt[i] + m_numEvt[i]) {
         ATH_MSG_INFO("found " << evtNum << " in file " << i);
         return i;
      }
   }
   ATH_MSG_INFO("did not find ev " << evtNum);
   // return file not found marker
   return -1;
}

initialize()

StatusCode EventSelectorByteStream::initialize ( )

overridevirtual

Implementation of Service base class methods.

Definition at line 84 of file EventSelectorByteStream.cxx.

                                               {
 
  m_autoRetrieveTools = false;
  m_checkToolDeps = false;
 
   if (m_isSecondary.value()) {
      ATH_MSG_DEBUG("Initializing secondary event selector " << name());
   } else {
      ATH_MSG_DEBUG("Initializing " << name());
   }
 
   ATH_CHECK(::AthService::initialize());
 
   // Check for input setting
   if (m_filebased && m_inputCollectionsProp.value().empty()) {
     ATH_MSG_FATAL("Unable to retrieve valid input list");
     return StatusCode::FAILURE;
   }
   m_skipEventSequence = m_skipEventSequenceProp.value();
   std::sort(m_skipEventSequence.begin(), m_skipEventSequence.end());
 
   // Check ByteStreamCnvSvc
   m_eventSource = serviceLocator()->service(m_eventSourceName.value());
   if (!m_eventSource) {
      ATH_MSG_FATAL("Cannot get ByteStreamInputSvc");
      return StatusCode::FAILURE;
   }
 
   // Get CounterTool (if configured)
   if (!m_counterTool.empty()) {
      ATH_CHECK(m_counterTool.retrieve());
   }
   // Get HelperTools
   if (!m_helperTools.empty()) {
      ATH_CHECK(m_helperTools.retrieve());
   }
   // Get SharedMemoryTool (if configured)
   if (!m_eventStreamingTool.empty()) {
      ATH_CHECK(m_eventStreamingTool.retrieve());
   }
 
   // Register this service for 'I/O' events
   ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
   ATH_CHECK(iomgr.retrieve());
   ATH_CHECK(iomgr->io_register(this));
 
   // Register the input files with the iomgr
   bool allGood = true;
   for (const std::string& input : m_inputCollectionsProp.value()) {
      if (!iomgr->io_register(this, IIoComponentMgr::IoMode::READ, input).isSuccess()) {
         ATH_MSG_FATAL("could not register [" << input << "] for output !");
         allGood = false;
      } else {
         ATH_MSG_VERBOSE("io_register[" << this->name() << "](" << input << ") [ok]");
      }
   }
   if (!allGood) {
      return(StatusCode::FAILURE);
   }
 
   // Make sure MetaDataSvc is initialized before the first file is opened
   ServiceHandle<IAthMetaDataSvc> metaDataSvc("MetaDataSvc", name());
   ATH_CHECK(metaDataSvc.retrieve());
 
   // Must happen before trying to open a file
   lock_t lock (m_mutex);
   StatusCode risc = this->reinit(lock);
 
   return risc;
}

inputCollectionsHandler()

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

private

Definition at line 63 of file EventSelectorByteStream.cxx.

                                                                               {
  lock_t lock (m_mutex);
  if (this->FSMState() != Gaudi::StateMachine::OFFLINE) {
    this->reinit(lock).ignore();
  }
}

io_reinit()

StatusCode EventSelectorByteStream::io_reinit ( )

overridevirtual

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

Definition at line 983 of file EventSelectorByteStream.cxx.

                                              {
   lock_t lock (m_mutex);
   ATH_MSG_INFO("I/O reinitialization...");
      ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
   ATH_CHECK(iomgr.retrieve());
   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();
   for (std::size_t i = 0, imax = inputCollections.size(); i != imax; ++i) {
      ATH_MSG_INFO("I/O reinitialization, file = "  << 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;
      }
      ATH_CHECK(iomgr->io_retrieve(this, fname));
   }
   // all good... copy over.
   m_inputFileGuard.reset();
 
   // Set m_inputCollectionsProp.  But we _dont_ want to run the update
   // handler --- that calls reinit(), which will deadlock since
   // we're holding the lock.  Instead, we'll call reinit() ourselves.
   auto old_cb = m_inputCollectionsProp.updateCallBack();
   m_inputCollectionsProp.declareUpdateHandler(
      [] (Gaudi::Details::PropertyBase&) {}
   );
   m_inputCollectionsProp = inputCollections;
   m_inputCollectionsProp.declareUpdateHandler (std::move(old_cb));
 
   return this->reinit(lock);
}

last()

StatusCode EventSelectorByteStream::last ( Context & it ) const

overridevirtual

Parameters

it	[IN/OUT] current event context is iterated to last event.

Definition at line 639 of file EventSelectorByteStream.cxx.

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

makeClient()

StatusCode EventSelectorByteStream::makeClient ( int num )

overridevirtual

Make this a client.

Definition at line 896 of file EventSelectorByteStream.cxx.

                                                    {
   lock_t lock (m_mutex);
   if (m_eventStreamingTool.empty()) {
      return StatusCode::FAILURE;
   }
   std::string dummyStr;
   return m_eventStreamingTool->makeClient(0, dummyStr);
}

makeServer()

StatusCode EventSelectorByteStream::makeServer ( int num )

overridevirtual

Make this a server.

Definition at line 887 of file EventSelectorByteStream.cxx.

                                                    {
   lock_t lock (m_mutex);
   if (m_eventStreamingTool.empty()) {
      return StatusCode::FAILURE;
   }
   return m_eventStreamingTool->makeServer(1, "");
}

next() [1/2]

virtual StatusCode EventSelectorByteStream::next ( Context & it ) const

overridevirtual

Parameters

it	[IN/OUT] current event context is iterated to next event.

next() [2/2]

virtual StatusCode EventSelectorByteStream::next ( Context & it, int jump ) const

overridevirtual

Parameters

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

nextFile()

void EventSelectorByteStream::nextFile ( lock_t & lock ) const

private

Definition at line 243 of file EventSelectorByteStream.cxx.

                                                      {
   // EndInputFile is handled by the InputFileIncidentGuard via transition()
   // when the next file is opened, or via reset() on stop().
   ++m_inputCollectionsIterator;
   ++m_fileCount;
}

nextHandleFileTransition()

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

overrideprotectedvirtual

Handle file transition at the next iteration.

Definition at line 463 of file EventSelectorByteStream.cxx.

{
  lock_t lock (m_mutex);
  return nextHandleFileTransitionImpl (ctxt, lock);
}

nextHandleFileTransitionImpl()

StatusCode EventSelectorByteStream::nextHandleFileTransitionImpl ( IEvtSelector::Context & ctxt, lock_t & lock ) const

private

Definition at line 468 of file EventSelectorByteStream.cxx.

{
   const RawEvent* pre{};
   bool badEvent{};
   // if event source not ready from init, try next file
   if (m_filebased && !m_eventSource->ready()) {
      // next file
      this->nextFile(lock);
      if (this->openNewRun(lock).isFailure()) {
         ATH_MSG_DEBUG("Event source found no more valid files left in input list");
         m_NumEvents = -1;
         return StatusCode::FAILURE;
      }
   }
   try {
      pre = m_eventSource->nextEvent();
   }
   catch (const ByteStreamExceptions::readError&) {
      ATH_MSG_FATAL("Caught ByteStreamExceptions::readError");
      return StatusCode::FAILURE;
   }
   catch (const ByteStreamExceptions::badFragment&) {
      ATH_MSG_ERROR("badFragment encountered");
      badEvent = true;
   }
   catch (const ByteStreamExceptions::badFragmentData&) {
      ATH_MSG_ERROR("badFragment data encountered");
      badEvent = true;
   }
   // Check whether a RawEvent has actually been provided
   if (pre == nullptr) {
      ctxt = *m_endIter;
      return StatusCode::FAILURE;
   }
 
   // If not secondary just return the status code based on if the event is bas
   if (!m_isSecondary.value()) {
      // check bad event flag and handle as configured
      return badEvent ? StatusCode::RECOVERABLE : StatusCode::SUCCESS;
   }
 
   // Build a DH for use by other components
   StatusCode rec_sg = m_eventSource->generateDataHeader();
   if (rec_sg != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Fail to record BS DataHeader in StoreGate. Skipping events?! " << rec_sg);
   }
 
   return StatusCode::SUCCESS;
}

nextImpl() [1/2]

StatusCode EventSelectorByteStream::nextImpl ( Context & it, int jump, lock_t & lock ) const

private

nextImpl() [2/2]

StatusCode EventSelectorByteStream::nextImpl ( Context & it, lock_t & lock ) const

private

nextWithSkip()

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

overrideprotectedvirtual

Go to next event and skip if necessary.

Definition at line 519 of file EventSelectorByteStream.cxx.

{
   lock_t lock (m_mutex);
   return nextWithSkipImpl (ctxt, lock);
}

nextWithSkipImpl()

StatusCode EventSelectorByteStream::nextWithSkipImpl ( IEvtSelector::Context & ctxt, lock_t & lock ) const

private

Definition at line 524 of file EventSelectorByteStream.cxx.

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

openNewRun()

StatusCode EventSelectorByteStream::openNewRun ( lock_t & lock ) const

private

Definition at line 250 of file EventSelectorByteStream.cxx.

                                                                 {
   // Should be protected upstream, but this is further protection
   if (!m_filebased) {
      ATH_MSG_ERROR("cannot open new run for non-filebased inputs");
      return StatusCode::FAILURE;
   }
   // Check for end of file list
   if (m_inputCollectionsIterator == m_inputCollectionsProp.value().end()) {
      ATH_MSG_INFO("End of input file list reached");
      return StatusCode::FAILURE;
   }
   std::string blockname = *m_inputCollectionsIterator;
   // try to open a file
   auto nevguid = m_eventSource->getBlockIterator(blockname);
   long nev = nevguid.first;
   if (nev == -1) {
      ATH_MSG_FATAL("Unable to access file " << *m_inputCollectionsIterator << ", stopping here");
      throw ByteStreamExceptions::fileAccessError();
   }
   // Fire EndInputFile for previous file (if any), then BeginInputFile for new file
   InputFileIncidentGuard::transition(m_inputFileGuard, *m_incidentSvc, name(),
                           "BSF:" + *m_inputCollectionsIterator, nevguid.second,
                           /*endFileName=*/{});
 
   // check if file is empty
   if (nev == 0) {
      ATH_MSG_WARNING("no events in file " << blockname << " try next");
      if (m_eventSource->ready()) m_eventSource->closeBlockIterator(true);
      this->nextFile(lock);
      return openNewRun(lock);
   // check if skipping all events in that file (minus events already skipped)
   } else if (m_skipEvents.value() - m_NumEvents > nev) {
      ATH_MSG_WARNING("skipping more events " << m_skipEvents.value() - m_NumEvents << "(" << nev <<") than in file " << *m_inputCollectionsIterator << ", try next");
      m_NumEvents += nev;
      m_numEvt[m_fileCount] = nev;
      if (m_eventSource->ready()) m_eventSource->closeBlockIterator(true);
      this->nextFile(lock);
      return openNewRun(lock);
   }
 
   ATH_MSG_DEBUG("Opened block/file " << blockname);
   m_firstEvt[m_fileCount] = m_NumEvents;
   m_numEvt[m_fileCount] = nev;
 
   return StatusCode::SUCCESS;
}

previous() [1/2]

virtual StatusCode EventSelectorByteStream::previous ( Context & it ) const

overridevirtual

Parameters

it	[IN/OUT] current event context is iterated to previous event.

previous() [2/2]

virtual StatusCode EventSelectorByteStream::previous ( Context & it, int jump ) const

overridevirtual

Parameters

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

previousImpl() [1/2]

StatusCode EventSelectorByteStream::previousImpl ( Context & it, int jump, lock_t & lock ) const

private

previousImpl() [2/2]

StatusCode EventSelectorByteStream::previousImpl ( Context & it, lock_t & lock ) const

private

readEvent()

StatusCode EventSelectorByteStream::readEvent ( int maxevt )

overridevirtual

Read the next maxevt events.

Parameters

evtnum

[IN] The number of events to read.

Definition at line 923 of file EventSelectorByteStream.cxx.

                                                        {
   lock_t lock (m_mutex);
   if (m_eventStreamingTool.empty()) {
      ATH_MSG_ERROR("No AthenaSharedMemoryTool configured for readEvent()");
      return StatusCode::FAILURE;
   }
   ATH_MSG_VERBOSE("Called read Event " << maxevt);
   for (int i = 0; i < maxevt || maxevt == -1; ++i) {
      const RawEvent* pre = nullptr;
      if (this->nextImpl(*m_beginIter, lock).isSuccess()) {
         pre = m_eventSource->currentEvent();
      } else {
         if (m_NumEvents == -1) {
            ATH_MSG_VERBOSE("Called read Event and read last event from input: " << i);
            break;
         }
         ATH_MSG_ERROR("Unable to retrieve next event for " << i << "/" << maxevt);
         return StatusCode::FAILURE;
      }
      if (m_eventStreamingTool->isServer()) {
         StatusCode sc;
         while ( (sc = putEvent_ST(*m_eventStreamingTool,
                                   m_NumEvents - 1,
                                   pre->start(),
                                   pre->fragment_size_word() * sizeof(uint32_t),
                                   m_eventSource->currentEventStatus())).isRecoverable() ) {
            usleep(1000);
         }
         ATH_CHECK(sc);
      }
   }
   // End of file, wait for last event to be taken
   StatusCode sc;
   while ( (sc = putEvent_ST(*m_eventStreamingTool, 0, 0, 0, 0)).isRecoverable() ) {
      usleep(1000);
   }
   ATH_CHECK(sc);
   return StatusCode::SUCCESS;
}

recordAttributeList()

StatusCode EventSelectorByteStream::recordAttributeList ( ) const

overrideprotectedvirtual

Record AttributeList in StoreGate.

Definition at line 714 of file EventSelectorByteStream.cxx.

{
  lock_t lock (m_mutex);
  return recordAttributeListImpl (lock);
}

recordAttributeListImpl()

StatusCode EventSelectorByteStream::recordAttributeListImpl ( lock_t & lock ) const

private

Definition at line 719 of file EventSelectorByteStream.cxx.

{
   std::string listName("EventInfoAtts");
 
   if (eventStore()->contains<AthenaAttributeList>(listName)) {
      const AthenaAttributeList* oldAttrList = nullptr;
      ATH_CHECK(eventStore()->retrieve(oldAttrList, listName));
      ATH_CHECK(eventStore()->removeDataAndProxy(oldAttrList));
   }
 
   // build the new attr list
   auto attrList = std::make_unique<AthenaAttributeList>();
 
   // fill the attr list
   ATH_CHECK(fillAttributeListImpl(attrList.get(), "", false, lock));
 
   // put result in event store
   ATH_CHECK(eventStore()->record(std::move(attrList), listName));
 
   return StatusCode::SUCCESS;
}

reinit()

StatusCode EventSelectorByteStream::reinit ( lock_t & lock )

private

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

Definition at line 155 of file EventSelectorByteStream.cxx.

                                                       {
   ATH_MSG_INFO("reinitialization...");
   // reset markers
   if (m_inputCollectionsProp.value().size()>0) {
      m_numEvt.resize(m_inputCollectionsProp.value().size(), -1);
      m_firstEvt.resize(m_inputCollectionsProp.value().size(), -1);
   }
   else {
      m_numEvt.resize(1);
      m_firstEvt.resize(1);
   }
 
   // Initialize InputCollectionsIterator
   m_inputCollectionsIterator = m_inputCollectionsProp.value().begin();
   m_NumEvents = 0;
   bool retError = false;
   if (!m_helperTools.empty()) {
      for (ToolHandle<IAthenaSelectorTool>& 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);
   }
 
   // If file based input then fire appropriate incidents
   if (m_filebased) {
      if (!m_firstFileFired) {
         FileIncident firstInputFileIncident(name(), "FirstInputFile", "BSF:" + *m_inputCollectionsIterator);
         m_incidentSvc->fireIncident(firstInputFileIncident);
         m_firstFileFired = true;
      }
 
      // try to open a file
      ATH_CHECK(this->openNewRun(lock));
   }
 
   return StatusCode::SUCCESS;
}

releaseContext()

StatusCode EventSelectorByteStream::releaseContext ( Context *& it ) const

overridevirtual

Parameters

it	[IN] current event context is released.

Definition at line 978 of file EventSelectorByteStream.cxx.

                                                                     {
   return StatusCode::SUCCESS;
}

resetCriteria()

StatusCode EventSelectorByteStream::resetCriteria ( const std::string & criteria, Context & context ) const

overridevirtual

Set a selection criteria.

Parameters

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

Definition at line 653 of file EventSelectorByteStream.cxx.

                                                                                                  {
   return StatusCode::SUCCESS;
}

rewind()

StatusCode EventSelectorByteStream::rewind ( Context & it ) const

overridevirtual

Parameters

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

Definition at line 647 of file EventSelectorByteStream.cxx.

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

seek()

StatusCode EventSelectorByteStream::seek ( Context & , int evtnum ) const

overridevirtual

Seek to a given event number.

Parameters

it	[IN/OUT] current event context.
evtnum	[IN] The event number to which to seek.

Definition at line 658 of file EventSelectorByteStream.cxx.

                                                                     {
   lock_t lock (m_mutex);
   // Check that input is seekable
   if (!m_filebased) {
      ATH_MSG_ERROR("Input not seekable, choose different input svc");
      return StatusCode::FAILURE;
   }
   // find the file index with that event
   long fileNum = findEvent(evtNum, lock);
   if (fileNum == -1 && evtNum >= m_firstEvt[m_fileCount] && evtNum < m_NumEvents) {
      fileNum = m_fileCount;
   }
   // if unable to locate file, exit
   if (fileNum == -1) {
      ATH_MSG_INFO("seek: Reached end of Input.");
      return StatusCode::RECOVERABLE;
   }
   // check if it is the current file
   if (fileNum != m_fileCount) { // event in different file
      // Close input file if open
      if (m_eventSource->ready()) m_eventSource->closeBlockIterator(true);
      ATH_MSG_DEBUG("Seek to item: \"" << m_inputCollectionsProp.value()[fileNum] << "\" from the explicit file list.");
      std::string fileName = m_inputCollectionsProp.value()[fileNum];
      m_fileCount = fileNum;
      // Open the correct file
      auto nevguid = m_eventSource->getBlockIterator(fileName);
      long nev = nevguid.first;
      if (nev == -1) {
         ATH_MSG_FATAL("Unable to open file with seeked event " << evtNum << " file " << fileName);
         return StatusCode::FAILURE;
      }
      int delta = evtNum - m_firstEvt[m_fileCount];
      if (delta > 0) {
        EventContextByteStream* beginIter ATLAS_THREAD_SAFE = m_beginIter;
        ATH_CHECK(nextImpl(*beginIter,delta, lock));
      }
   }
   // event in current file
   {
      int delta = (evtNum - m_firstEvt[m_fileCount] + 1) - m_eventSource->positionInBlock();
      ATH_MSG_DEBUG("Seeking event " << evtNum << " in current file with delta " << delta);
      if ( delta == 0 ) { // current event
         // nothing to do
      }
      else if ( delta > 0 ) { // forward
         EventContextByteStream* beginIter ATLAS_THREAD_SAFE = m_beginIter;
         ATH_CHECK(this->nextImpl(*beginIter, delta, lock));
      }
      else if ( delta < 0 ) { // backward
         EventContextByteStream* beginIter ATLAS_THREAD_SAFE = m_beginIter;
         ATH_CHECK(this->previousImpl(*beginIter, -1*delta, lock));
      }
   }
   return StatusCode::SUCCESS;
}

share()

StatusCode EventSelectorByteStream::share ( int evtnum )

overridevirtual

Request to share a given event number.

Parameters

evtnum

[IN] The event number to share.

Definition at line 906 of file EventSelectorByteStream.cxx.

                                                    {
   lock_t lock (m_mutex);
   if (m_eventStreamingTool.empty()) {
      return StatusCode::FAILURE;
   }
   if (m_eventStreamingTool->isClient()) {
      StatusCode sc = m_eventStreamingTool->lockEvent(evtNum);
      while (sc.isRecoverable()) {
         usleep(1000);
         sc = m_eventStreamingTool->lockEvent(evtNum);
      }
      return sc;
   }
   return StatusCode::FAILURE;
}

size()

int EventSelectorByteStream::size ( Context & it ) const

overridevirtual

Always returns -1.

Parameters

it	[IN/OUT] current event context.

Definition at line 882 of file EventSelectorByteStream.cxx.

                                                   {
  return -1;
}

start()

StatusCode EventSelectorByteStream::start ( )

overridevirtual

Definition at line 200 of file EventSelectorByteStream.cxx.

                                          {
   ATH_MSG_DEBUG("Calling EventSelectorByteStream::start()");
   lock_t lock (m_mutex);
   // Create the begin and end iterator's for this selector.
   m_beginIter =  new EventContextByteStream(this);
   // Increment to get the new event in.
   m_endIter   =  new EventContextByteStream(0);
 
   return StatusCode::SUCCESS;
}

stop()

StatusCode EventSelectorByteStream::stop ( )

overridevirtual

Definition at line 212 of file EventSelectorByteStream.cxx.

                                         {
   ATH_MSG_DEBUG("Calling EventSelectorByteStream::stop()");
   if (m_filebased) {
      // Fire EndInputFile for any file still open
      m_inputFileGuard.reset();
      if (m_eventSource->ready()) {
         m_eventSource->closeBlockIterator(false);
      }
   }
   return StatusCode::SUCCESS;
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/8]

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

mutableprivate

RAII guard: guarantees a matching EndInputFile for every BeginInputFile.

Definition at line 200 of file EventSelectorByteStream.h.

ATLAS_THREAD_SAFE [2/8]

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

mutableprivate

Definition at line 179 of file EventSelectorByteStream.h.

{this, "SharedMemoryTool", "", ""};

ATLAS_THREAD_SAFE [3/8]

long m_NumEvents EventSelectorByteStream::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 178 of file EventSelectorByteStream.h.

ATLAS_THREAD_SAFE [4/8]

std::vector<long> m_skipEventSequence EventSelectorByteStream::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 177 of file EventSelectorByteStream.h.

ATLAS_THREAD_SAFE [5/8]

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

mutableprivate

Definition at line 176 of file EventSelectorByteStream.h.

ATLAS_THREAD_SAFE [6/8]

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

mutableprivate

Definition at line 175 of file EventSelectorByteStream.h.

ATLAS_THREAD_SAFE [7/8]

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

mutableprivate

Definition at line 174 of file EventSelectorByteStream.h.

ATLAS_THREAD_SAFE [8/8]

int m_fileCount EventSelectorByteStream::ATLAS_THREAD_SAFE = 0

mutableprivate

number of files to process.

Definition at line 173 of file EventSelectorByteStream.h.

m_beginIter

EventContextByteStream* EventSelectorByteStream::m_beginIter {}

private

Definition at line 188 of file EventSelectorByteStream.h.

{};

m_counterTool

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

private

Definition at line 204 of file EventSelectorByteStream.h.

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

m_endIter

EventContextByteStream* EventSelectorByteStream::m_endIter {}

private

Definition at line 189 of file EventSelectorByteStream.h.

{};

m_eventSource

SmartIF<IByteStreamInputSvc> EventSelectorByteStream::m_eventSource

private

Definition at line 190 of file EventSelectorByteStream.h.

m_eventSourceName

Gaudi::Property<std::string> EventSelectorByteStream::m_eventSourceName {this, "ByteStreamInputSvc", "", ""}

private

Definition at line 184 of file EventSelectorByteStream.h.

{this, "ByteStreamInputSvc", "", ""};

m_eventsPerLB

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

private

Definition at line 216 of file EventSelectorByteStream.h.

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

m_eventsPerRun

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

private

Definition at line 214 of file EventSelectorByteStream.h.

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

m_filebased

Gaudi::Property<bool> EventSelectorByteStream::m_filebased {this, "FileBased", true, ""}

private

Definition at line 210 of file EventSelectorByteStream.h.

{this, "FileBased", true, ""};

m_firstEventNo

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

private

Definition at line 213 of file EventSelectorByteStream.h.

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

m_firstFileFired

bool EventSelectorByteStream::m_firstFileFired {}

private

Definition at line 198 of file EventSelectorByteStream.h.

{};

m_firstLBNo

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

private

Definition at line 215 of file EventSelectorByteStream.h.

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

m_helperTools

ToolHandleArray<IAthenaSelectorTool> EventSelectorByteStream::m_helperTools {this, "HelperTools", {}, "Helper tools executed by EventSelector"}

private

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

Definition at line 203 of file EventSelectorByteStream.h.

{this, "HelperTools", {}, "Helper tools executed by EventSelector"};

m_incidentSvc

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

private

Definition at line 193 of file EventSelectorByteStream.h.

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

m_initTimeStamp

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

private

Definition at line 217 of file EventSelectorByteStream.h.

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

m_inputCollectionsProp

Gaudi::Property<std::vector<std::string> > EventSelectorByteStream::m_inputCollectionsProp {this, "Input", {}, ""}

private

Definition at line 191 of file EventSelectorByteStream.h.

{this, "Input", {}, ""};

m_isSecondary

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

private

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

Definition at line 182 of file EventSelectorByteStream.h.

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

m_maxBadEvts

Gaudi::Property<int> EventSelectorByteStream::m_maxBadEvts {this, "MaxBadEvents", -1, ""}

private

number of bad events allowed before quitting.

Definition at line 186 of file EventSelectorByteStream.h.

{this, "MaxBadEvents", -1, ""};         

m_mutex

mutex_t EventSelectorByteStream::m_mutex

mutableprivate

Definition at line 172 of file EventSelectorByteStream.h.

m_overrideRunNumber

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

private

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 209 of file EventSelectorByteStream.h.

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

m_procBadEvent

Gaudi::Property<bool> EventSelectorByteStream::m_procBadEvent {this, "ProcessBadEvent", false, ""}

private

process bad events, which fail check_tree().

Definition at line 185 of file EventSelectorByteStream.h.

{this, "ProcessBadEvent", false, ""}; 

m_runNo

Gaudi::CheckedProperty<uint32_t> EventSelectorByteStream::m_runNo {this, "RunNumber", 0, ""}

private

Definition at line 212 of file EventSelectorByteStream.h.

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

m_skipEvents

Gaudi::Property<long> EventSelectorByteStream::m_skipEvents {this, "SkipEvents", 0, ""}

private

Definition at line 195 of file EventSelectorByteStream.h.

{this, "SkipEvents", 0, ""}; // Number of events to skip at the beginning

m_skipEventSequenceProp

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

private

Definition at line 196 of file EventSelectorByteStream.h.

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

m_timeStampInterval

Gaudi::Property<uint32_t> EventSelectorByteStream::m_timeStampInterval {this, "TimeStampInterval", 0, ""}

private

Definition at line 218 of file EventSelectorByteStream.h.

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

---

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

• EventSelectorByteStream.h
• EventSelectorByteStream.cxx