TrigByteStreamCnvSvc Class Reference

A ByteStreamCnvSvc implementation for online use. More...

#include <TrigByteStreamCnvSvc.h>

Inheritance diagram for TrigByteStreamCnvSvc:

Collaboration diagram for TrigByteStreamCnvSvc:

Public Member Functions
	TrigByteStreamCnvSvc (const std::string &name, ISvcLocator *svcLoc)
	Standard constructor.
virtual	~TrigByteStreamCnvSvc ()
	Standard destructor.
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	connectOutput (const std::string &outputFile) override
	In the case of online BS data, this method creates the output FullEventFragment and fills its header.
StatusCode	connectOutput (const std::string &outputFile, const EventContext &eventContext)
	In the case of online BS data, this method creates the output FullEventFragment and fills its header.
virtual StatusCode	connectOutput (const std::string &outputFile, const std::string &openMode) override
	This overload is kept only for interface compatibility.
virtual StatusCode	commitOutput (const std::string &outputFile, bool do_commit) override
	In the case of online BS data, this method binds and sends out the output FullEventFragment.
StatusCode	commitOutput (const std::string &outputFile, bool do_commit, const EventContext &eventContext)
	In the case of online BS data, this method binds and sends out the output FullEventFragment.
virtual RawEventWrite *	getRawEvent () override
	Return a pointer to the raw event for the current event context.
RawEventWrite *	getRawEvent (const EventContext &eventContext) const
	Return a pointer to the raw event for the given event context.

Protected Member Functions
virtual FullEventAssemblerBase *	findFullEventAssembler (const std::string &name) const override
virtual StatusCode	storeFullEventAssembler (std::unique_ptr< FullEventAssemblerBase > fea, const std::string &name) override

Private Member Functions
RawEventWrite *	setRawEvent (std::unique_ptr< RawEventWrite > &&rawEventWrite, const EventContext &eventContext)
	Store new raw event in the cache.
void	clearRawEvent (const EventContext &eventContext)
	Delete raw event from the cache.
void	printRawEvent (const EventContext &eventContext) const
	Print contents of the raw event.
void	monitorRawEvent (const std::unique_ptr< uint32_t[]> &rawEventPtr) const
	Fill histograms from contents of a FullEventFragment.
const EventContext *	currentContext () const
	Hack used in HLT to avoid using ThreadLocalContext, see explanation in the implementation.

Private Attributes
ServiceHandle< StoreGateSvc >	m_evtStore {this, "EventStore", "StoreGateSvc"}
ServiceHandle< IROBDataProviderSvc >	m_robDataProviderSvc {this, "ROBDataProvider", "ROBDataProviderSvc"}
ServiceHandle< EFInterfaceSvc >	m_efInterfaceSvc {this, "EFInterfaceSvc", "", "Online service managing EF interface with Dataflow"}
ToolHandle< GenericMonitoringTool >	m_monTool {this, "MonTool", "" , "Monitoring tool"}
SG::SlotSpecificObj< std::unique_ptr< RawEventWrite > >	m_rawEventWriteCache
bool	m_hasEFInterface {false}

Detailed Description

A ByteStreamCnvSvc implementation for online use.

It overrides the connectOutput and commitOutput methods of the base class. In this implementation, they create the specific online HLT output and send it out directly to the TDAQ infrastructure without using an output service.

Definition at line 24 of file TrigByteStreamCnvSvc.h.

Constructor & Destructor Documentation

TrigByteStreamCnvSvc()

TrigByteStreamCnvSvc::TrigByteStreamCnvSvc	(	const std::string &	name,
		ISvcLocator *	svcLoc )

Standard constructor.

Definition at line 80 of file TrigByteStreamCnvSvc.cxx.

  : base_class(name, svcLoc) {}

~TrigByteStreamCnvSvc()

TrigByteStreamCnvSvc::~TrigByteStreamCnvSvc ( )

virtual

Standard destructor.

Definition at line 86 of file TrigByteStreamCnvSvc.cxx.

{}

Member Function Documentation

clearRawEvent()

void TrigByteStreamCnvSvc::clearRawEvent ( const EventContext & eventContext )

private

Delete raw event from the cache.

Definition at line 286 of file TrigByteStreamCnvSvc.cxx.

                                                                         {
  m_rawEventWriteCache.get(eventContext)->reset();
}

commitOutput() [1/2]

StatusCode TrigByteStreamCnvSvc::commitOutput ( const std::string & outputFile, bool do_commit )

overridevirtual

In the case of online BS data, this method binds and sends out the output FullEventFragment.

Definition at line 185 of file TrigByteStreamCnvSvc.cxx.

                                                                                         {
  const EventContext* eventContext = currentContext();
  if (eventContext == nullptr) return StatusCode::FAILURE;
  return commitOutput(outputFile, do_commit, *eventContext);
}

commitOutput() [2/2]

StatusCode TrigByteStreamCnvSvc::commitOutput	(	const std::string &	outputFile,
		bool	do_commit,
		const EventContext &	eventContext )

In the case of online BS data, this method binds and sends out the output FullEventFragment.

Definition at line 191 of file TrigByteStreamCnvSvc.cxx.

                                                                                                          {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
 
  if (msgLvl(MSG::DEBUG)) printRawEvent(eventContext);
 
  RawEventWrite* re = getRawEvent(eventContext);
 
  // Serialise the output FullEventFragment
  std::unique_ptr<uint32_t[]> rawEventPtr;
  try {
    const eformat::write::node_t* top = re->bind();
    uint32_t rawEventSize = re->size_word();
    rawEventPtr = std::make_unique<uint32_t[]>(rawEventSize);
    uint32_t copiedSize = eformat::write::copy(*top,rawEventPtr.get(),rawEventSize);
    if(copiedSize!=rawEventSize) {
      ATH_MSG_ERROR("FullEventFragment serialisation failed");
      return StatusCode::FAILURE;
    }
  }
  catch (const std::exception& e) {
    ATH_MSG_ERROR("FullEventFragment serialisation failed, caught an unexpected std::exception " << e.what());
    clearRawEvent(eventContext);
    return StatusCode::FAILURE;
  }
  catch (...) {
    ATH_MSG_ERROR("FullEventFragment serialisation failed, caught an unexpected exception");
    clearRawEvent(eventContext);
    return StatusCode::FAILURE;
  }
 
  {
    auto t_mon = Monitored::Timer("TIME_monitorRawEvent");
    monitorRawEvent(rawEventPtr);
    Monitored::Group(m_monTool, t_mon);
  }
 
  // Send output to the DataCollector
  StatusCode result = StatusCode::SUCCESS;
  try {
    auto t_eventDone = Monitored::Timer<std::chrono::duration<float, std::milli>>("TIME_eventDone");
    if (m_hasEFInterface)
      m_efInterfaceSvc->eventDone(std::move(rawEventPtr));
    else
      hltinterface::DataCollector::instance()->eventDone(std::move(rawEventPtr));
    Monitored::Group(m_monTool, t_eventDone);
    ATH_MSG_DEBUG("Serialised FullEventFragment with HLT result was returned to DataCollector successfully, "
                  << "the eventDone call took " << (double)t_eventDone << " milliseconds");
  }
  catch (const std::exception& e) {
    ATH_MSG_ERROR("Sending output to DataCollector failed, caught an unexpected std::exception " << e.what());
    result = StatusCode::FAILURE;
  }
  catch (...) {
    ATH_MSG_ERROR("Sending output to DataCollector failed, caught an unexpected exception");
    result = StatusCode::FAILURE;
  }
 
  clearRawEvent(eventContext);
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return result;
}

connectOutput() [1/3]

StatusCode TrigByteStreamCnvSvc::connectOutput ( const std::string & outputFile )

overridevirtual

In the case of online BS data, this method creates the output FullEventFragment and fills its header.

Definition at line 147 of file TrigByteStreamCnvSvc.cxx.

                                                                          {
  const EventContext* eventContext = currentContext();
  if (eventContext == nullptr) return StatusCode::FAILURE;
  return connectOutput(outputFile, *eventContext);
}

connectOutput() [2/3]

StatusCode TrigByteStreamCnvSvc::connectOutput	(	const std::string &	outputFile,
		const EventContext &	eventContext )

In the case of online BS data, this method creates the output FullEventFragment and fills its header.

Definition at line 153 of file TrigByteStreamCnvSvc.cxx.

                                                                                                   {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
 
  ATH_MSG_DEBUG("Creating new RawEventWrite for EventContext = " << eventContext);
  // Create a new RawEventWrite and copy the header from the input RawEvent
  RawEventWrite* re = setRawEvent(std::make_unique<RawEventWrite>(), eventContext);
  const uint32_t* inputRawEvent = m_robDataProviderSvc->getEvent(eventContext)->start();
  if (!inputRawEvent) {
    ATH_MSG_ERROR("Input RawEvent is nullptr, cannot create output");
    return StatusCode::FAILURE;
  }
  re->copy_header(inputRawEvent);
 
  ATH_MSG_VERBOSE("Created RawEventWrite pointer = " << re);
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}

connectOutput() [3/3]

StatusCode TrigByteStreamCnvSvc::connectOutput ( const std::string & outputFile, const std::string & openMode )

overridevirtual

This overload is kept only for interface compatibility.

Definition at line 176 of file TrigByteStreamCnvSvc.cxx.

                                                                                              {
  return connectOutput(outputFile);
}

currentContext()

const EventContext * TrigByteStreamCnvSvc::currentContext ( ) const

private

Hack used in HLT to avoid using ThreadLocalContext, see explanation in the implementation.

Definition at line 255 of file TrigByteStreamCnvSvc.cxx.

                                                               {
  // Get the EventContext via event store because the base class doesn't allow passing it explicitly as an argument
  // and we don't want to use ThreadLocalContext. Don't use ReadHandle here because it calls ThreadLocalContext if
  // not given a context (which we want to retrieve). This relies on IHiveWhiteBoard::selectStore being called on the
  // current thread before we arrive here (it is done in HltEventLoopMgr).
  const EventContext* eventContext = nullptr;
  if (m_evtStore->retrieve(eventContext).isFailure()) {
    ATH_MSG_ERROR("Failed to retrieve EventContext from the event store");
  }
  return eventContext;
}

finalize()

StatusCode TrigByteStreamCnvSvc::finalize ( )

overridevirtual

Definition at line 114 of file TrigByteStreamCnvSvc.cxx.

                                          {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
  if (m_robDataProviderSvc.release().isFailure())
    ATH_MSG_WARNING("Failed to release service " << m_robDataProviderSvc.typeAndName());
  if (m_hasEFInterface){
    if (m_efInterfaceSvc.release().isFailure())
      ATH_MSG_WARNING("Failed to release service " << m_efInterfaceSvc.typeAndName());
  } 
  if (m_evtStore.release().isFailure())
    ATH_MSG_WARNING("Failed to release service " << m_evtStore.typeAndName());
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  ATH_CHECK(ByteStreamCnvSvcBase::finalize());
  return StatusCode::SUCCESS;
}

findFullEventAssembler()

FullEventAssemblerBase * TrigByteStreamCnvSvc::findFullEventAssembler ( const std::string & name ) const

overrideprotectedvirtual

Definition at line 132 of file TrigByteStreamCnvSvc.cxx.

                                                                                             {
  ATH_MSG_ERROR("Bytestream creation is not supported by TrigByteStreamCnvSvc");
  return nullptr;
}

getRawEvent() [1/2]

RawEventWrite * TrigByteStreamCnvSvc::getRawEvent ( )

overridevirtual

Return a pointer to the raw event for the current event context.

Definition at line 268 of file TrigByteStreamCnvSvc.cxx.

                                                 {
  const EventContext* eventContext = currentContext();
  if (eventContext == nullptr) return nullptr;
  return getRawEvent(*eventContext);
}

getRawEvent() [2/2]

RawEventWrite * TrigByteStreamCnvSvc::getRawEvent

(

const EventContext &

eventContext

)

const

Return a pointer to the raw event for the given event context.

Definition at line 275 of file TrigByteStreamCnvSvc.cxx.

                                                                                       {
  return m_rawEventWriteCache.get(eventContext)->get();
}

initialize()

StatusCode TrigByteStreamCnvSvc::initialize ( )

overridevirtual

Definition at line 91 of file TrigByteStreamCnvSvc.cxx.

                                            {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
  ATH_CHECK(ByteStreamCnvSvcBase::initialize());
  ATH_CHECK(m_evtStore.retrieve());
  ATH_CHECK(m_robDataProviderSvc.retrieve());
    //Check if EFInterfaceSvc is available and set flag for selecting which interface to use
  if (!m_efInterfaceSvc.empty()) {
    ATH_MSG_INFO("Using EFInterfaceSvc");
    ATH_CHECK(m_efInterfaceSvc.retrieve());
    m_hasEFInterface = true;
  }
  else {
    ATH_MSG_INFO("Using legacy dataflow interface");
    m_hasEFInterface = false;
  }
  if (!m_monTool.empty()) ATH_CHECK(m_monTool.retrieve());
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}

monitorRawEvent()

void TrigByteStreamCnvSvc::monitorRawEvent ( const std::unique_ptr< uint32_t[]> & rawEventPtr ) const

private

Fill histograms from contents of a FullEventFragment.

Definition at line 291 of file TrigByteStreamCnvSvc.cxx.

                                                                                             {
  // Create a read fragment from the pointer
  eformat::read::FullEventFragment rawEvent(rawEventPtr.get());
 
  // Monitor error code
  if (rawEvent.nstatus() > 1) {
    HLT::OnlineErrorCode errorCode = static_cast<HLT::OnlineErrorCode>(rawEvent.status()[1]);
    std::ostringstream ss;
    ss << errorCode;
    auto monOnlineErrorCode = Monitored::Scalar<std::string>("OnlineErrorCode", ss.str());
    Monitored::Group(m_monTool, monOnlineErrorCode);
  }
 
  // Decode stream tags
  std::vector<eformat::helper::StreamTag> streamTags;
  try {
    eformat::helper::decode(rawEvent.nstream_tag(), rawEvent.stream_tag(), streamTags);
  }
  catch (const std::exception& ex) {
    ATH_MSG_ERROR("StreamTag decoding failed, caught an unexpected std::exception " << ex.what());
    return;
  }
  catch (...) {
    ATH_MSG_ERROR("StreamTag decoding failed, caught an unexpected exception");
    return;
  }
 
  // Get HLT result sizes
  std::vector<eformat::read::ROBFragment> robs;
  rawEvent.robs(robs);
  std::vector<uint16_t> resultSizeMap_moduleID;
  std::vector<uint32_t> resultSizeMap_size;
  uint32_t totalSizeWords = 0;
  try {
    for (const eformat::read::ROBFragment& rob : robs) {
      eformat::helper::SourceIdentifier sid(rob.rob_source_id());
      if (sid.subdetector_id() != eformat::SubDetector::TDAQ_HLT)
        continue;
      const uint16_t module_id = sid.module_id();
      const uint32_t size = rob.fragment_size_word();
      totalSizeWords += size;
      if (!contains(resultSizeMap_moduleID, module_id)) {
        resultSizeMap_moduleID.push_back(module_id);
        resultSizeMap_size.push_back(size);
      }
      else {
        ATH_MSG_ERROR("HLT result ROB monitoring found multiple HLT ROBs with the same module ID " << module_id);
      }
    }
  }
  catch (const std::exception& ex) {
    ATH_MSG_ERROR("HLT result ROB monitoring failed, caught an unexpected std::exception " << ex.what());
    return;
  }
  catch (...) {
    ATH_MSG_ERROR("HLT result ROB monitoring failed, caught an unexpected exception");
    return;
  }
 
  // Fill helper containers for monitoring
  std::vector<std::string> sdFromRobList;
  std::vector<std::string> sdFromSubDetList;
  std::vector<std::string> streamTagCorrA;
  std::vector<std::string> streamTagCorrB;
  std::vector<float> streamResultSize; // Correlated with streamTags vector
  streamTagCorrA.reserve(streamTags.size() * streamTags.size());
  streamTagCorrB.reserve(streamTags.size() * streamTags.size());
  streamResultSize.reserve(streamTags.size());
  for (const eformat::helper::StreamTag& st : streamTags) {
    bool hasHLTSubDet = st.dets.find(eformat::SubDetector::TDAQ_HLT) != st.dets.end();
    bool includeAll = st.robs.empty() && (st.dets.empty() || hasHLTSubDet);
    // includeAll means a stream with full event building or all HLT results included
    uint32_t sizeWords = includeAll ? totalSizeWords : 0;
    for (const eformat::SubDetector sd : st.dets) {
      const std::string& detName = eformat::helper::SubDetectorDictionary.string(sd);
      if (!contains(sdFromSubDetList, detName)) sdFromSubDetList.push_back(detName);
    }
    for (const uint32_t robid : st.robs) {
      eformat::helper::SourceIdentifier sid(robid);
      const std::string& detName = sid.human_detector();
      if (!contains(sdFromRobList, detName)) sdFromRobList.push_back(detName);
      if (!includeAll && sid.subdetector_id() == eformat::SubDetector::TDAQ_HLT) {
        if (const int ix = index(resultSizeMap_moduleID, sid.module_id()); ix >= 0) {
          sizeWords += resultSizeMap_size[ix];
        }
        else {
          ATH_MSG_WARNING("Stream tag " << st.type << "_" << st.name << " declares " << sid.human()
                          << " in ROB list, but the ROBFragment is missing");
        }
      }
    }
    streamResultSize.push_back(sizeWords*wordsToKiloBytes);
    for (const eformat::helper::StreamTag& st2 : streamTags) {
      streamTagCorrA.push_back(mon_streamTypeName(st));
      streamTagCorrB.push_back(mon_streamTypeName(st2));
    }
  }
 
  // General stream tag monitoring
  auto monStreamTagsNum         = Monitored::Scalar<size_t>("StreamTagsNum", streamTags.size());
  auto monStreamTags            = Monitored::Collection("StreamTags", streamTags, mon_streamTypeName);
  auto monStreamTagsType        = Monitored::Collection("StreamTagsType", streamTags, mon_streamType);
  auto monStreamTagCorrA        = Monitored::Collection("StreamTagCorrA", streamTagCorrA);
  auto monStreamTagCorrB        = Monitored::Collection("StreamTagCorrB", streamTagCorrB);
  // PEB stream tag monitoring
  auto monStreamIsPeb           = Monitored::Collection("StreamTagIsPeb", streamTags, mon_streamIsPeb);
  auto monPebRobsNum            = Monitored::Collection("StreamTagsPebRobsNum", streamTags, mon_streamPebRobsNum);
  auto monPebSubDetsNum         = Monitored::Collection("StreamTagsPebSubDetsNum", streamTags, mon_streamPebSubDetsNum);
  auto monSubDetsFromRobList    = Monitored::Collection("StreamTagsPebSubDetsFromRobList", sdFromRobList);
  auto monSubDetsFromSubDetList = Monitored::Collection("StreamTagsPebSubDetsFromSubDetList", sdFromSubDetList);
  // Result size monitoring
  auto monResultSizeTotal       = Monitored::Scalar<float>("ResultSizeTotal", totalSizeWords*wordsToKiloBytes);
  auto monResultSizeFullEvFrag  = Monitored::Scalar<float>("ResultSizeFullEvFrag", rawEvent.fragment_size_word()*wordsToKiloBytes);
  auto monResultCollModuleID    = Monitored::Collection("ResultModuleID", resultSizeMap_moduleID);
  auto monResultCollModuleSize  = Monitored::Collection("ResultModuleSize", resultSizeMap_size, [](uint32_t sw){return sw*wordsToKiloBytes;});
  auto monResultSizeByStream    = Monitored::Collection("ResultSizeStream", streamResultSize);
  // Collect all variables
  Monitored::Group(m_monTool, monStreamTagsNum, monStreamTags, monStreamTagsType, monStreamTagCorrA,
                   monStreamTagCorrB, monStreamIsPeb, monPebRobsNum, monPebSubDetsNum, monSubDetsFromRobList,
                   monSubDetsFromSubDetList, monResultSizeTotal, monResultSizeFullEvFrag, monResultCollModuleID,
                   monResultCollModuleSize, monResultSizeByStream);
}

printRawEvent()

void TrigByteStreamCnvSvc::printRawEvent ( const EventContext & eventContext ) const

private

Print contents of the raw event.

Definition at line 415 of file TrigByteStreamCnvSvc.cxx.

                                                                               {
  RawEventWrite* re = getRawEvent(eventContext);
 
  if (!re) {
    ATH_MSG_WARNING("RawEventWrite pointer is null");
    return;
  }
  std::ostringstream ss;
  ss << "Dumping header of the FullEventFragment with HLT result:" << std::endl;
  ss << "--> status              = "
     << printNWordsHex<uint32_t>(re->nstatus(), re->status())
     << std::endl;
  ss << "--> source_id           = " << printWordHex<uint32_t>(re->source_id()) << std::endl;
  ss << "--> checksum_type       = " << printWordHex<uint32_t>(re->checksum_type()) << std::endl;
  ss << "--> compression_type    = " << printWordHex<uint32_t>(re->compression_type()) << std::endl;
  ss << "--> compression_level   = " << re->compression_level() << std::endl;
  ss << "--> bc_time_seconds     = " << re->bc_time_seconds() << std::endl;
  ss << "--> bc_time_nanoseconds = " << re->bc_time_nanoseconds() << std::endl;
  ss << "--> global_id           = " << re->global_id() << std::endl;
  ss << "--> run_type            = " << re->run_type() << std::endl;
  ss << "--> run_no              = " << re->run_no() << std::endl;
  ss << "--> lumi_block          = " << re->lumi_block() << std::endl;
  ss << "--> lvl1_id             = " << re->lvl1_id() << std::endl;
  ss << "--> bc_id               = " << re->bc_id() << std::endl;
  ss << "--> lvl1_trigger_type   = " << printWordHex<uint8_t>(re->lvl1_trigger_type()) << std::endl;
  ss << "--> lvl1_trigger_info   = "
     << printNWordsHex<uint32_t>(re->nlvl1_trigger_info(), re->lvl1_trigger_info())
     << std::endl;
  ss << "--> lvl2_trigger_info   = "
     << printNWordsHex<uint32_t>(re->nlvl2_trigger_info(), re->lvl2_trigger_info())
     << std::endl;
  ss << "--> event_filter_info   = "
     << printNWordsHex<uint32_t>(re->nevent_filter_info(), re->event_filter_info())
     << std::endl;
  ss << "--> hlt_info            = "
     << printNWordsHex<uint32_t>(re->nhlt_info(), re->hlt_info())
     << std::endl;
 
  std::vector<eformat::helper::StreamTag> stream_tags;
  try {
    eformat::helper::decode(re->nstream_tag(), re->stream_tag(), stream_tags);
  }
  catch (const std::exception& ex) {
    ATH_MSG_ERROR("StreamTag decoding failed, caught an unexpected std::exception " << ex.what());
    return;
  }
  catch (...) {
    ATH_MSG_ERROR("StreamTag decoding failed, caught an unexpected exception");
    return;
  }
  ss << "--> stream_tags         = ";
  bool first = true;
  for (const auto& st : stream_tags) {
    if (first) first=false;
    else ss << "                          ";
    ss << "{" << st.name << ", " << st.type << ", obeysLB=" << st.obeys_lumiblock << ", robs=[";
    for (const auto& robid : st.robs) ss << printWordHex<uint32_t>(robid) << ", ";
    ss << "], dets = [";
    for (const auto& detid : st.dets) ss << printWordHex<uint8_t>(detid) << ", ";
    ss << "]}" << std::endl;
  }
 
  ATH_MSG_DEBUG(ss.str());
}

setRawEvent()

RawEventWrite * TrigByteStreamCnvSvc::setRawEvent ( std::unique_ptr< RawEventWrite > && rawEventWrite, const EventContext & eventContext )

private

Store new raw event in the cache.

Definition at line 280 of file TrigByteStreamCnvSvc.cxx.

                                                                                                                               {
  *(m_rawEventWriteCache.get(eventContext)) = std::move(rawEventWrite);
  return getRawEvent(eventContext);
}

storeFullEventAssembler()

StatusCode TrigByteStreamCnvSvc::storeFullEventAssembler ( std::unique_ptr< FullEventAssemblerBase > fea, const std::string & name )

overrideprotectedvirtual

Definition at line 137 of file TrigByteStreamCnvSvc.cxx.

                                                                             {
  ATH_MSG_ERROR("Bytestream creation is not supported by TrigByteStreamCnvSvc");
  return StatusCode::FAILURE;
}

Member Data Documentation

m_efInterfaceSvc

ServiceHandle<EFInterfaceSvc> TrigByteStreamCnvSvc::m_efInterfaceSvc {this, "EFInterfaceSvc", "", "Online service managing EF interface with Dataflow"}

private

Definition at line 75 of file TrigByteStreamCnvSvc.h.

{this, "EFInterfaceSvc", "", "Online service managing EF interface with Dataflow"};

m_evtStore

ServiceHandle<StoreGateSvc> TrigByteStreamCnvSvc::m_evtStore {this, "EventStore", "StoreGateSvc"}

private

Definition at line 73 of file TrigByteStreamCnvSvc.h.

{this, "EventStore", "StoreGateSvc"};

m_hasEFInterface

bool TrigByteStreamCnvSvc::m_hasEFInterface {false}

private

Definition at line 80 of file TrigByteStreamCnvSvc.h.

{false}; 

m_monTool

ToolHandle<GenericMonitoringTool> TrigByteStreamCnvSvc::m_monTool {this, "MonTool", "" , "Monitoring tool"}

private

Definition at line 76 of file TrigByteStreamCnvSvc.h.

{this, "MonTool", "" , "Monitoring tool"};

m_rawEventWriteCache

SG::SlotSpecificObj<std::unique_ptr<RawEventWrite> > TrigByteStreamCnvSvc::m_rawEventWriteCache

private

Definition at line 79 of file TrigByteStreamCnvSvc.h.

m_robDataProviderSvc

ServiceHandle<IROBDataProviderSvc> TrigByteStreamCnvSvc::m_robDataProviderSvc {this, "ROBDataProvider", "ROBDataProviderSvc"}

private

Definition at line 74 of file TrigByteStreamCnvSvc.h.

{this, "ROBDataProvider", "ROBDataProviderSvc"};

---

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

• TrigByteStreamCnvSvc.h
• TrigByteStreamCnvSvc.cxx