implements the interface IByteStreamInputSvc for reading events from emon. More...

#include <ByteStreamEmonInputSvc.h>

Inheritance diagram for ByteStreamEmonInputSvc:

Collaboration diagram for ByteStreamEmonInputSvc:

Public Member Functions
	ByteStreamEmonInputSvc (const std::string &name, ISvcLocator *svcloc)
	Constructors: More...

virtual StatusCode	initialize () override

virtual StatusCode	start () override

virtual StatusCode	finalize () override

virtual const RawEvent *	previousEvent () override
	Implementation of the ByteStreamInputSvc interface methods. More...

virtual const RawEvent *	nextEvent () override

virtual const RawEvent *	currentEvent () const override
	Implementation of the ByteStreamInputSvc interface methods. More...

Private Member Functions
bool	getIterator ()

void	check_publish ()

void	get_runparams ()

void	updateHandler (Gaudi::Details::PropertyBase &p)

Private Attributes
int	m_totalEventCounter {0}
	event Counter More...

std::unique_ptr< RawEvent >	m_re {nullptr}
	current event More...

Gaudi::Property< std::string >	m_partition {this, "Partition", {}, "Partition name, default taken from $TDAQ_PARTITION if not set"}

Gaudi::Property< std::string >	m_key {this, "Key", {}, &ByteStreamEmonInputSvc::updateHandler, "EMON Selection key, e.g. SFI"}

Gaudi::Property< std::vector< std::string > >	m_value {this, "KeyValue", {}, &ByteStreamEmonInputSvc::updateHandler, "EMON key values, e.g. [SFI-1, SFI-2]; if empty all SFIs"}

Gaudi::Property< unsigned int >	m_key_count {this, "KeyCount", 0, &ByteStreamEmonInputSvc::updateHandler, "EMON key count, e.g. 5 to get five random SFIs"}

Gaudi::Property< std::string >	m_publish {this, "PublishName", "Athena", &ByteStreamEmonInputSvc::updateHandler, "Name under which to publish histograms"}

Gaudi::Property< bool >	m_exit {this, "ExitOnPartitionShutdown", false, &ByteStreamEmonInputSvc::updateHandler, "If true, exit if partition shuts down"}

Gaudi::Property< std::string >	m_is_server {this, "ISServer", "", &ByteStreamEmonInputSvc::updateHandler, "IS Server to publish histograms to"}

Gaudi::Property< std::string >	m_include {this, "Include", {}, &ByteStreamEmonInputSvc::updateHandler, "Regular expression to select histograms to publish"}

Gaudi::Property< std::string >	m_exclude {this, "Exclude", {}, &ByteStreamEmonInputSvc::updateHandler, "Regular expression to select histograms not to publish"}

Gaudi::Property< int >	m_frequency {this, "Frequency", 60, &ByteStreamEmonInputSvc::updateHandler, "Frequency (in number of events) of publishing histograms"}

Gaudi::Property< int >	m_updatePeriod {this, "UpdatePeriod", 0, &ByteStreamEmonInputSvc::updateHandler, "Frequency (in seconds) of publishing histograms"}

Gaudi::Property< float >	m_updatePeriodRange {this, "UpdatePeriodRange", 0.2, "A percentage number to determine how close we have to be to the next update time to publish now"}

Gaudi::Property< bool >	m_clearHistograms {this, "ClearHistograms", true, &ByteStreamEmonInputSvc::updateHandler, "If true, clear histograms when new run starts (default: True)"}

Gaudi::Property< std::vector< std::string > >	m_l1names {this, "LVL1Names", {}, &ByteStreamEmonInputSvc::updateHandler, "A list of L1 bit names"}

Gaudi::Property< std::vector< unsigned int > >	m_l1items {this, "LVL1Items", {}, &ByteStreamEmonInputSvc::updateHandler, "A list of L1 bit numbers"}

Gaudi::Property< std::string >	m_l1logic {this, "LVL1Logic", "Ignore", &ByteStreamEmonInputSvc::updateHandler, "'And', 'Or' or 'Ignore' (default: Ignore)"}

Gaudi::Property< std::string >	m_l1origin {this, "LVL1Origin", "TAV", &ByteStreamEmonInputSvc::updateHandler, "TBP, TAP, TAV (default: TAV"}

Gaudi::Property< std::string >	m_stream_type {this, "StreamType", "physics", &ByteStreamEmonInputSvc::updateHandler, "HLT stream type (e.g. physics or calibration)"}

Gaudi::Property< std::vector< std::string > >	m_stream_names {this, "StreamNames", {}, &ByteStreamEmonInputSvc::updateHandler, "List of HLT stream names"}

Gaudi::Property< std::string >	m_stream_logic {this, "StreamLogic", "Ignore", &ByteStreamEmonInputSvc::updateHandler, "'And', 'Or' or 'Ignore' (default: Ignore)"}

Gaudi::Property< unsigned int >	m_trigger_type {this, "TriggerType", 256, &ByteStreamEmonInputSvc::updateHandler, "LVL1 8 bit trigger type"}

Gaudi::Property< std::string >	m_groupName {this, "GroupName", {}, &ByteStreamEmonInputSvc::updateHandler, "Name of the monitoring group"}

Gaudi::Property< unsigned int >	m_buffer_size {this, "BufferSize", 2, "Number of buffers"}

Gaudi::Property< bool >	m_readDetectorMask {this, "ReadDetectorMaskFromIS", true, "Read detector mask from IS"}

Gaudi::Property< int >	m_timeout {this, "Timeout", 3600000, &ByteStreamEmonInputSvc::updateHandler, "Timeout in seconds, -1 == infinity"}

Gaudi::Property< bool >	m_corrupted_events {this, "ProcessCorruptedEvents", false, &ByteStreamEmonInputSvc::updateHandler, "Process corrupted events not passing check_tree()"}

Gaudi::Property< std::string >	m_state {this, "State", "None", "Read-only property showing the state"}

Gaudi::Property< bool >	m_convertEfficiency {this, "ConvertEfficiency", true, "Convert TEfficiency to TProfile before publishing"}

SG::ReadHandleKey< TrigConf::L1Menu >	m_l1MenuKey {this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "Name of the L1Menu object to read configuration from"}

bool	m_connect {false}

std::auto_ptr< emon::EventIterator >	m_eventIt
	Event iterator. More...

OHRootProvider *	m_provider {nullptr}

boost::regex	m_include_rex

boost::regex	m_exclude_rex

int	m_frequency_counter {60}

int	m_publish_target {0}

ServiceHandle< StoreGateSvc >	m_inputMetaDataStore

ServiceHandle< StoreGateSvc >	m_sgSvc

ServiceHandle< IROBDataProviderSvc >	m_robProvider

ServiceHandle< ITHistSvc >	m_histSvc

Detailed Description

implements the interface IByteStreamInputSvc for reading events from emon.

Definition at line 37 of file ByteStreamEmonInputSvc.h.

Constructor & Destructor Documentation

◆ ByteStreamEmonInputSvc()

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

Constructors:

Definition at line 152 of file ByteStreamEmonInputSvc.cxx.

                                                                                          :
     base_class(name,svcloc),
     m_inputMetaDataStore("StoreGateSvc/InputMetaDataStore", name ),
     m_sgSvc("StoreGateSvc", name),
     m_robProvider("ROBDataProviderSvc", name),
     m_histSvc("THistSvc", name)
 {
 }

Member Function Documentation

◆ check_publish()

void ByteStreamEmonInputSvc::check_publish ( )

private

Definition at line 483 of file ByteStreamEmonInputSvc.cxx.

 {
     // is a server specified ?
     if(m_is_server.empty()) return;
  
     // a time based update ?
     if(m_updatePeriod) {
         time_t now = time(0);
  
         if(now < m_publish_target - int(m_updatePeriodRange * m_updatePeriod)) {
             // it's too early to publish
             return;
         }
  
         if(now > m_publish_target + int(m_updatePeriodRange * m_updatePeriod)) {
             // it's too late
             unsigned int missed_publications = 0;
             while(m_publish_target < now) {
                 missed_publications++;
                 m_publish_target += m_updatePeriod;
             }
  
             // do NOT publish, but print a warning
             ATH_MSG_WARNING(" check_publish: missed " << missed_publications << " publications to OH");
  
             return;
         }
     }
  
     // an event based update ?
     if(m_frequency && --m_frequency_counter > 0) return;
  
     m_frequency_counter = m_frequency;
  
     try { 
  
         if(m_provider == nullptr) {
             IPCPartition part(m_partition);
             if(!part.isValid()) return;
             // might throw...
             m_provider = new OHRootProvider(part, m_is_server, m_publish);
         }
  
         for(const std::string& name : m_histSvc->getHists()) {
  
             if(!m_include.empty() && !regex_match(name, m_include_rex)) {
                 continue;
             }
  
             if(!m_exclude.empty() && regex_match(name, m_exclude_rex)) {
                 continue;
             }
  
             TH1 *h = nullptr;
             if(m_histSvc->getHist(name, h)) {
                 // might throw...
                 auto name_tag = detail::extract_histogram_tag(name);
                 m_provider->publish(*h, name_tag.first, name_tag.second);
             };
         }
         for(const std::string& name : m_histSvc->getEfficiencies()) {
  
             if(!m_include.empty() && !regex_match(name, m_include_rex)) {
                 continue;
             }
  
             if(!m_exclude.empty() && regex_match(name, m_exclude_rex)) {
                 continue;
             }
  
             TEfficiency *h = nullptr;
             if(m_histSvc->getEfficiency(name, h)) {
                 if (m_convertEfficiency) {
                     std::unique_ptr<const TH1> p;
                     if (h->GetDimension() == 1) {
                         p = create1DProfile(h);
                     } else if (h->GetDimension() == 2) {
                         p = create2DProfile(h);
                     }
                     // might throw...
                     auto name_tag = detail::extract_histogram_tag(name);
                     m_provider->publish(*p, name_tag.first, name_tag.second);
                     //m_provider->publish(*h, name_tag.first, name_tag.second);
                 } // tdaq doesn't currently support publishing efficiencies, will change in the future
             };
         }
     } catch (daq::oh::Exception& ex) {
         ATH_MSG_ERROR(ex.what());
     } 
  
     m_publish_target += m_updatePeriod;
 }

◆ currentEvent()

const RawEvent * ByteStreamEmonInputSvc::currentEvent ( ) const

overridevirtual

Implementation of the ByteStreamInputSvc interface methods.

Definition at line 478 of file ByteStreamEmonInputSvc.cxx.

 {
     return m_re.get();
 }

◆ finalize()

StatusCode ByteStreamEmonInputSvc::finalize ( )

overridevirtual

Definition at line 652 of file ByteStreamEmonInputSvc.cxx.

 {
     setProperty("State","Shutdown").ignore();
     m_inputMetaDataStore.release().ignore();
     m_robProvider.release().ignore();
     m_sgSvc.release().ignore();
     return StatusCode::SUCCESS;
 }

◆ get_runparams()

void ByteStreamEmonInputSvc::get_runparams ( )

private

Definition at line 576 of file ByteStreamEmonInputSvc.cxx.

 {
     IPCPartition p(m_partition);
     
     RunParamsNamed runParams(p, "RunParams.RunParams");
     try {
         runParams.checkout();
  
         eformat::helper::DetectorMask mask(runParams.det_mask);
  
         auto metadatacont = std::make_unique<ByteStreamMetadataContainer>();
         metadatacont->push_back(std::make_unique<ByteStreamMetadata>(
                  runParams.run_number,
                  0,
                  0,
                  runParams.recording_enabled,
                  runParams.trigger_type,
                  mask.serialize().second,
                  runParams.beam_type,
                  runParams.beam_energy,
                  "",
                  "",
                  runParams.T0_project_tag,
                  0,
                  std::vector<std::string>()
                  ));
         // Record ByteStreamMetadataContainer in MetaData Store
         if(m_inputMetaDataStore->record(std::move(metadatacont),"ByteStreamMetadata").isFailure()) {
            ATH_MSG_WARNING("Unable to record MetaData in InputMetaDataStore");
         }
         else {
            ATH_MSG_DEBUG("Recorded MetaData in InputMetaDataStore");
         }
  
     } catch(ers::Issue& ex) {
         ATH_MSG_ERROR("Cannot get run parameters:" << ex.what());
     }
 }

◆ getIterator()

bool ByteStreamEmonInputSvc::getIterator ( )

private

Definition at line 222 of file ByteStreamEmonInputSvc.cxx.

 {
     setProperty("State", "Init").ignore();
  
     if(!IPCCore::isInitialised()) {
         char* argv[2] = { 0 };
         int argc = 0;
         IPCCore::init(argc, argv);
     }
  
     IPCPartition partition(m_partition);
     while(!partition.isValid()) {
         if(m_exit) {
             ATH_MSG_ERROR("No such partition: " << m_partition);
             return false;
         }
         ATH_MSG_INFO("No such partition (yet?): " << m_partition);
         sleep(20);
     }
  
     delete m_provider;
     m_provider = nullptr;
  
     std::unique_ptr<emon::SamplingAddress> address;
  
     if(m_key_count > 0) {
         address.reset(new emon::SamplingAddress(m_key, m_key_count));
     }  else {
         address.reset(new emon::SamplingAddress(m_key, m_value));
     }
  
     emon::Logic  l1_logic = emon::logic::IGNORE;
     emon::Logic  stream_logic = emon::logic::IGNORE;
     emon::Origin l1_origin = emon::origin::AFTER_VETO;
  
     if(m_l1logic == "Or") {
         l1_logic = emon::logic::OR;
     } else if (m_l1logic == "And") {
         l1_logic = emon::logic::AND;
     } else if (m_l1logic == "Ignore") {
         l1_logic = emon::logic::IGNORE;
     }
  
     if(m_l1origin == "TBP") {
         l1_origin = emon::origin::BEFORE_PRESCALE;
     } else if (m_l1origin == "TAP") {
         l1_origin = emon::origin::AFTER_PRESCALE;
     } else if(m_l1origin == "TAV") {
         l1_origin = emon::origin::AFTER_VETO;
     } else {
         ATH_MSG_FATAL("Invalid L1 origin");
     }
  
     if(m_stream_logic == "Or") {
         stream_logic = emon::logic::OR;
     } else if (m_stream_logic == "And") {
         stream_logic = emon::logic::AND;
     } else if (m_stream_logic == "Ignore") {
         stream_logic = emon::logic::IGNORE;
     }
  
     // now put together the bit mask from all
     // three sources: l1 bit mask, l1 names, l1 items
  
     std::vector<unsigned short> l1bits(m_l1items.begin(), m_l1items.end());
  
     // if names are given, read the mapping information from L1Menu
     if (not m_l1names.value().empty()) {
         ATH_MSG_DEBUG("Reading L1Menu to map " << m_l1names.name() << " to CTP IDs");
         SG::ReadHandle<TrigConf::L1Menu> l1Menu = SG::makeHandle(m_l1MenuKey);
         if (not l1Menu.isValid()) {
             ATH_MSG_ERROR("Cannot read L1Menu to map L1 item names to IDs. The property " << m_l1names.name() << " will be ignored!");
         } else {
             for (const std::string& l1name : m_l1names) {
                 try {
                     const unsigned int id = l1Menu->item(l1name).ctpId();
                     ATH_MSG_DEBUG("Item " << l1name << " mapped to CTP ID " << id);
                     l1bits.push_back(static_cast<unsigned short>(id));
                 } catch (const std::exception& ex) {
                     ATH_MSG_ERROR(ex.what());
                     continue;
                 }
             }
         }
     }
  
     typedef emon::MaskedValue<unsigned char>    L1TriggerType;
     
     emon::SmartBitValue l1pattern(l1bits, l1_logic, l1_origin);
     emon::SmartStreamValue streamTags(m_stream_type, m_stream_names, stream_logic);
  
     emon::L1TriggerType l1triggerType(static_cast<unsigned char>(m_trigger_type), m_trigger_type > 255);
  
     emon::SelectionCriteria criteria(l1triggerType,
                                      l1pattern,
                                      streamTags,
                                      emon::StatusWord());
  
     while (true) {
  
         if (partition.name() != m_partition) {
             ATH_MSG_INFO("Partition name changed - reconnecting to " << m_partition);
             return getIterator();
         }
  
     try {
             m_eventIt.reset(0);
             m_eventIt.reset(new emon::EventIterator(partition, *address, criteria, m_buffer_size, m_groupName));
             if(m_readDetectorMask) {
                 get_runparams();
             }
             setProperty("State", "Connected").ignore();
         return true;
     } catch(ers::Issue& ex) {
         ATH_MSG_INFO("Cannot connect to sampler (will wait 20s): " << m_key << "/" << m_value
                      << " Reason: " << ex.what());
         sleep(20);
     }
     }
 }

◆ initialize()

StatusCode ByteStreamEmonInputSvc::initialize ( )

overridevirtual

Definition at line 162 of file ByteStreamEmonInputSvc.cxx.

 {
     setProperty("State", "Init").ignore();
  
     // check properties
     if(m_partition.empty() && getenv("TDAQ_PARTITION") != 0) {
         m_partition = getenv("TDAQ_PARTITION");
     }
  
     if(m_partition.empty()){
         ATH_MSG_ERROR("initialize: No partition name specified");
         return StatusCode::FAILURE;
     }
      
     if(m_key.empty()) {
         ATH_MSG_ERROR("initialize: No emon key ");
         return StatusCode::FAILURE;
     } 
  
     m_connect = true;
  
     if (m_histSvc.retrieve().isFailure()) {
         ATH_MSG_ERROR("Unable to locate THistSvc");
         m_is_server.clear();
     } else {
         if(!m_include.empty()) m_include_rex = m_include.value();
         if(!m_exclude.empty()) m_exclude_rex = m_exclude.value();
         if(m_frequency < 0) m_frequency = 100000;
         m_frequency_counter = m_frequency;
  
         // if time based update, disable frequency based update
         if(m_updatePeriod) {
             m_frequency = 0;
             // calculate our next target for publishing
             time_t now = time(0);
             m_publish_target = now - (now % m_updatePeriod) + m_updatePeriod;
         }
     }
  
     //-------------------------------------------------------------------------
     // Setup the InputMetaDataStore
     //-------------------------------------------------------------------------
     ATH_CHECK( m_inputMetaDataStore.retrieve() );
     ATH_CHECK( m_robProvider.retrieve() );
  
     // Initialise the L1Menu read handle if we need to map L1 item names to IDs
     ATH_CHECK(m_l1MenuKey.initialize(not m_l1names.value().empty()));
  
     signal(SIGTERM, handle_terminate);
  
     // Read run parameters from the partition
     if (m_readDetectorMask) {
         get_runparams();
     }
  
     ATH_MSG_INFO("initialized for: " << m_partition << " " << m_key << "/" << m_value);
  
     return StatusCode::SUCCESS;
 }

◆ nextEvent()

const RawEvent * ByteStreamEmonInputSvc::nextEvent ( )

overridevirtual

Definition at line 352 of file ByteStreamEmonInputSvc.cxx.

 {
     if (m_re) {
         OFFLINE_FRAGMENTS_NAMESPACE::PointerType st = nullptr;
         m_re->start(st);
         if (st) delete [] st;
         m_re.reset();
     }
  
     while(m_re == nullptr) {
  
         if(m_connect) {
        
             if(!getIterator()) {
                 return nullptr;
             }  else {
                 ATH_MSG_INFO("Got sampler...");
                 m_connect = false;
             }
         }
        
         emon::Event event;
         try {
             int timeout = m_timeout;
             if(m_updatePeriod) {
                 // try to hit lower end of update period
                 timeout = (m_publish_target - time(0) - int(m_updatePeriodRange * m_updatePeriod)) * 1000;
                 if(timeout <= 0) timeout = 1000;
             }
             event = m_eventIt->nextEvent(timeout);
         } catch(emon::NoMoreEvents& ex) {
             if(m_exit) {
                 return nullptr;
             }
             check_publish();
             continue;
         } catch (ers::Issue& ex) {
             m_connect = true;
             continue;
         }
  
         setProperty("State", "Processing").ignore();
        
         OFFLINE_FRAGMENTS_NAMESPACE::DataType* buf = new OFFLINE_FRAGMENTS_NAMESPACE::DataType[event.size()];
         memcpy(buf, event.data(), event.size() * sizeof(OFFLINE_FRAGMENTS_NAMESPACE::DataType));
  
  
         if (buf[0] == eformat::FULL_EVENT) {
  
             // We got a full event
             m_re = std::make_unique<RawEvent>(buf);
             try {
                 m_re->check_tree();
                 ATH_MSG_INFO("nextEvent: Got valid fragment of size:" << event.size());
             } catch (ers::Issue& ex) {
           
                 // log in any case
         std::stringstream ss;
         ss << ex;
                 ATH_MSG_ERROR("nextEvent: Invalid event fragment: " << ss.str());
                
                 if(!m_corrupted_events) {
  
                     delete [] buf;
                     m_re.reset();
                     continue;
                 } // else fall through
             }
         m_robProvider->setNextEvent(Gaudi::Hive::currentContext(), m_re.get());
         m_robProvider->setEventStatus(Gaudi::Hive::currentContext(), 0);        
  
         } else {
             // We got something we didn't expect.
             ATH_MSG_ERROR("nextEvent: Got invalid fragment of unknown type: 0x"
                           << std::hex << buf[0] << std::dec);
             delete [] buf;
             continue;
         }
         ++m_totalEventCounter;
     }
  
     // generate DataHeader
     DataHeader* Dh = new DataHeader();
     
    // Declare header primary
     Dh->setStatus(DataHeader::Input);
  
     // Now add ref to xAOD::EventInfo objects
     IOpaqueAddress* iop = new ByteStreamAddress(ClassID_traits<xAOD::EventInfo>::ID(), "EventInfo", "");
     StatusCode ioc = m_sgSvc->recordAddress("EventInfo",iop);
     if (ioc.isSuccess()) {
         const SG::DataProxy* ptmp = m_sgSvc->transientProxy(ClassID_traits<xAOD::EventInfo>::ID(), "EventInfo");
         if (ptmp !=0) {
             DataHeaderElement DheEI(ptmp, nullptr, "EventInfo");
             Dh->insert(DheEI);
         }
         //else ATH_MSG_ERROR("Failed to create xAOD::EventInfo proxy " << ptmp);
     }
  
     // Now add ref to xAOD::EventAuxInfo objects
     IOpaqueAddress* iopaux = new ByteStreamAddress(ClassID_traits<xAOD::EventAuxInfo>::ID(), "EventInfoAux.", "");
     StatusCode iocaux = m_sgSvc->recordAddress("EventInfoAux.",iopaux);
     if (iocaux.isSuccess()) {
         const SG::DataProxy* ptmpaux = m_sgSvc->transientProxy(ClassID_traits<xAOD::EventAuxInfo>::ID(), "EventInfoAux.");
         if (ptmpaux !=0) {
             DataHeaderElement DheEIAux(ptmpaux, nullptr, "EventInfoAux.");
             Dh->insert(DheEIAux);
         }
         //else ATH_MSG_ERROR("Failed to create xAOD::EventAuxInfo proxy " << ptmpaux);
     }
  
     // Record new data header.Boolean flags will allow it's deletion in case
     // of skipped events.
     StatusCode rec_sg = m_sgSvc->record<DataHeader>(Dh, "ByteStreamDataHeader", true, false, true);
     if (rec_sg != StatusCode::SUCCESS) {
         ATH_MSG_ERROR("Fail to record BS DataHeader in StoreGate. Skipping events?! " << rec_sg);
     }
  
     // we got an event, check if we have to publish
     check_publish();
  
     return m_re.get();
  
 }

◆ previousEvent()

const RawEvent * ByteStreamEmonInputSvc::previousEvent ( )

overridevirtual

Implementation of the ByteStreamInputSvc interface methods.

Definition at line 344 of file ByteStreamEmonInputSvc.cxx.

 {
     ATH_MSG_WARNING("previousEvent not implemented for ByteStreamEmonInputSvc");
  
     return nullptr;
 }

◆ start()

StatusCode ByteStreamEmonInputSvc::start ( )

overridevirtual

Definition at line 616 of file ByteStreamEmonInputSvc.cxx.

 {
     if(m_clearHistograms) {
         ATH_MSG_INFO("Resetting histograms...");
         for(const std::string& name : m_histSvc->getHists()) {
             TH1 *h = nullptr;
             if(m_histSvc->getHist(name, h)) {
                 h->Reset();
             };
         }
         for(const std::string& name : m_histSvc->getEfficiencies()) {
             TEfficiency *h = nullptr;
             if(m_histSvc->getEfficiency(name, h)) {
                 std::unique_ptr<TH1> pass{h->GetCopyPassedHisto()};
                 pass->Reset();
                 h->SetPassedHistogram(*pass.get(), "");
                 std::unique_ptr<TH1> tot{h->GetCopyTotalHisto()};
                 tot->Reset();
                 h->SetTotalHistogram(*tot.get(), "");
                 h->SetWeight(1);
             };
         }
     }
     return StatusCode::SUCCESS;
 }

◆ updateHandler()

void ByteStreamEmonInputSvc::updateHandler ( Gaudi::Details::PropertyBase & p )

private

Definition at line 642 of file ByteStreamEmonInputSvc.cxx.

 {
     if(! m_connect) {
         m_connect = true;
         sleep(2);
         setProperty("State","Reconnect").ignore();
     }
 }

Member Data Documentation

◆ m_buffer_size

Gaudi::Property<unsigned int> ByteStreamEmonInputSvc::m_buffer_size {this, "BufferSize", 2, "Number of buffers"}

private

Definition at line 90 of file ByteStreamEmonInputSvc.h.

◆ m_clearHistograms

Gaudi::Property<bool> ByteStreamEmonInputSvc::m_clearHistograms {this, "ClearHistograms", true, &ByteStreamEmonInputSvc::updateHandler, "If true, clear histograms when new run starts (default: True)"}

private

Definition at line 79 of file ByteStreamEmonInputSvc.h.

◆ m_connect

bool ByteStreamEmonInputSvc::m_connect {false}

private

Definition at line 101 of file ByteStreamEmonInputSvc.h.

◆ m_convertEfficiency

Gaudi::Property<bool> ByteStreamEmonInputSvc::m_convertEfficiency {this, "ConvertEfficiency", true, "Convert TEfficiency to TProfile before publishing"}

private

Definition at line 95 of file ByteStreamEmonInputSvc.h.

◆ m_corrupted_events

Gaudi::Property<bool> ByteStreamEmonInputSvc::m_corrupted_events {this, "ProcessCorruptedEvents", false, &ByteStreamEmonInputSvc::updateHandler, "Process corrupted events not passing check_tree()"}

private

Definition at line 93 of file ByteStreamEmonInputSvc.h.

◆ m_eventIt

std::auto_ptr<emon::EventIterator> ByteStreamEmonInputSvc::m_eventIt

private

Event iterator.

Definition at line 102 of file ByteStreamEmonInputSvc.h.

◆ m_exclude

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_exclude {this, "Exclude", {}, &ByteStreamEmonInputSvc::updateHandler, "Regular expression to select histograms not to publish"}

private

Definition at line 75 of file ByteStreamEmonInputSvc.h.

◆ m_exclude_rex

boost::regex ByteStreamEmonInputSvc::m_exclude_rex

private

Definition at line 107 of file ByteStreamEmonInputSvc.h.

◆ m_exit

Gaudi::Property<bool> ByteStreamEmonInputSvc::m_exit {this, "ExitOnPartitionShutdown", false, &ByteStreamEmonInputSvc::updateHandler, "If true, exit if partition shuts down"}

private

Definition at line 72 of file ByteStreamEmonInputSvc.h.

◆ m_frequency

Gaudi::Property<int> ByteStreamEmonInputSvc::m_frequency {this, "Frequency", 60, &ByteStreamEmonInputSvc::updateHandler, "Frequency (in number of events) of publishing histograms"}

private

Definition at line 76 of file ByteStreamEmonInputSvc.h.

◆ m_frequency_counter

int ByteStreamEmonInputSvc::m_frequency_counter {60}

private

Definition at line 109 of file ByteStreamEmonInputSvc.h.

◆ m_groupName

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_groupName {this, "GroupName", {}, &ByteStreamEmonInputSvc::updateHandler, "Name of the monitoring group"}

private

Definition at line 89 of file ByteStreamEmonInputSvc.h.

◆ m_histSvc

ServiceHandle<ITHistSvc> ByteStreamEmonInputSvc::m_histSvc

private

Definition at line 115 of file ByteStreamEmonInputSvc.h.

◆ m_include

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_include {this, "Include", {}, &ByteStreamEmonInputSvc::updateHandler, "Regular expression to select histograms to publish"}

private

Definition at line 74 of file ByteStreamEmonInputSvc.h.

◆ m_include_rex

boost::regex ByteStreamEmonInputSvc::m_include_rex

private

Definition at line 106 of file ByteStreamEmonInputSvc.h.

◆ m_inputMetaDataStore

ServiceHandle<StoreGateSvc> ByteStreamEmonInputSvc::m_inputMetaDataStore

private

Definition at line 112 of file ByteStreamEmonInputSvc.h.

◆ m_is_server

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_is_server {this, "ISServer", "", &ByteStreamEmonInputSvc::updateHandler, "IS Server to publish histograms to"}

private

Definition at line 73 of file ByteStreamEmonInputSvc.h.

◆ m_key

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_key {this, "Key", {}, &ByteStreamEmonInputSvc::updateHandler, "EMON Selection key, e.g. SFI"}

private

Definition at line 68 of file ByteStreamEmonInputSvc.h.

◆ m_key_count

Gaudi::Property<unsigned int> ByteStreamEmonInputSvc::m_key_count {this, "KeyCount", 0, &ByteStreamEmonInputSvc::updateHandler, "EMON key count, e.g. 5 to get five random SFIs"}

private

Definition at line 70 of file ByteStreamEmonInputSvc.h.

◆ m_l1items

Gaudi::Property<std::vector<unsigned int> > ByteStreamEmonInputSvc::m_l1items {this, "LVL1Items", {}, &ByteStreamEmonInputSvc::updateHandler, "A list of L1 bit numbers"}

private

Definition at line 81 of file ByteStreamEmonInputSvc.h.

◆ m_l1logic

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_l1logic {this, "LVL1Logic", "Ignore", &ByteStreamEmonInputSvc::updateHandler, "'And', 'Or' or 'Ignore' (default: Ignore)"}

private

Definition at line 82 of file ByteStreamEmonInputSvc.h.

◆ m_l1MenuKey

SG::ReadHandleKey<TrigConf::L1Menu> ByteStreamEmonInputSvc::m_l1MenuKey {this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "Name of the L1Menu object to read configuration from"}

private

Definition at line 98 of file ByteStreamEmonInputSvc.h.

◆ m_l1names

Gaudi::Property<std::vector<std::string> > ByteStreamEmonInputSvc::m_l1names {this, "LVL1Names", {}, &ByteStreamEmonInputSvc::updateHandler, "A list of L1 bit names"}

private

Definition at line 80 of file ByteStreamEmonInputSvc.h.

◆ m_l1origin

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_l1origin {this, "LVL1Origin", "TAV", &ByteStreamEmonInputSvc::updateHandler, "TBP, TAP, TAV (default: TAV"}

private

Definition at line 83 of file ByteStreamEmonInputSvc.h.

◆ m_partition

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_partition {this, "Partition", {}, "Partition name, default taken from $TDAQ_PARTITION if not set"}

private

Definition at line 67 of file ByteStreamEmonInputSvc.h.

◆ m_provider

OHRootProvider* ByteStreamEmonInputSvc::m_provider {nullptr}

private

Definition at line 104 of file ByteStreamEmonInputSvc.h.

◆ m_publish

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_publish {this, "PublishName", "Athena", &ByteStreamEmonInputSvc::updateHandler, "Name under which to publish histograms"}

private

Definition at line 71 of file ByteStreamEmonInputSvc.h.

◆ m_publish_target

int ByteStreamEmonInputSvc::m_publish_target {0}

private

Definition at line 110 of file ByteStreamEmonInputSvc.h.

◆ m_re

std::unique_ptr<RawEvent> ByteStreamEmonInputSvc::m_re {nullptr}

private

current event

Definition at line 64 of file ByteStreamEmonInputSvc.h.

◆ m_readDetectorMask

Gaudi::Property<bool> ByteStreamEmonInputSvc::m_readDetectorMask {this, "ReadDetectorMaskFromIS", true, "Read detector mask from IS"}

private

Definition at line 91 of file ByteStreamEmonInputSvc.h.

◆ m_robProvider

ServiceHandle<IROBDataProviderSvc> ByteStreamEmonInputSvc::m_robProvider

private

Definition at line 114 of file ByteStreamEmonInputSvc.h.

◆ m_sgSvc

ServiceHandle<StoreGateSvc> ByteStreamEmonInputSvc::m_sgSvc

private

Definition at line 113 of file ByteStreamEmonInputSvc.h.

◆ m_state

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_state {this, "State", "None", "Read-only property showing the state"}

private

Definition at line 94 of file ByteStreamEmonInputSvc.h.

◆ m_stream_logic

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_stream_logic {this, "StreamLogic", "Ignore", &ByteStreamEmonInputSvc::updateHandler, "'And', 'Or' or 'Ignore' (default: Ignore)"}

private

Definition at line 86 of file ByteStreamEmonInputSvc.h.

◆ m_stream_names

Gaudi::Property<std::vector<std::string> > ByteStreamEmonInputSvc::m_stream_names {this, "StreamNames", {}, &ByteStreamEmonInputSvc::updateHandler, "List of HLT stream names"}

private

Definition at line 85 of file ByteStreamEmonInputSvc.h.

◆ m_stream_type

Gaudi::Property<std::string> ByteStreamEmonInputSvc::m_stream_type {this, "StreamType", "physics", &ByteStreamEmonInputSvc::updateHandler, "HLT stream type (e.g. physics or calibration)"}

private

Definition at line 84 of file ByteStreamEmonInputSvc.h.

◆ m_timeout

Gaudi::Property<int> ByteStreamEmonInputSvc::m_timeout {this, "Timeout", 3600000, &ByteStreamEmonInputSvc::updateHandler, "Timeout in seconds, -1 == infinity"}

private

Definition at line 92 of file ByteStreamEmonInputSvc.h.

◆ m_totalEventCounter

int ByteStreamEmonInputSvc::m_totalEventCounter {0}

private

event Counter

Definition at line 62 of file ByteStreamEmonInputSvc.h.

◆ m_trigger_type

Gaudi::Property<unsigned int> ByteStreamEmonInputSvc::m_trigger_type {this, "TriggerType", 256, &ByteStreamEmonInputSvc::updateHandler, "LVL1 8 bit trigger type"}

private

Definition at line 88 of file ByteStreamEmonInputSvc.h.

◆ m_updatePeriod

Gaudi::Property<int> ByteStreamEmonInputSvc::m_updatePeriod {this, "UpdatePeriod", 0, &ByteStreamEmonInputSvc::updateHandler, "Frequency (in seconds) of publishing histograms"}

private

Definition at line 77 of file ByteStreamEmonInputSvc.h.

◆ m_updatePeriodRange

Gaudi::Property<float> ByteStreamEmonInputSvc::m_updatePeriodRange {this, "UpdatePeriodRange", 0.2, "A percentage number to determine how close we have to be to the next update time to publish now"}

private

Definition at line 78 of file ByteStreamEmonInputSvc.h.

◆ m_value

Gaudi::Property<std::vector<std::string> > ByteStreamEmonInputSvc::m_value {this, "KeyValue", {}, &ByteStreamEmonInputSvc::updateHandler, "EMON key values, e.g. [SFI-1, SFI-2]; if empty all SFIs"}

private

Definition at line 69 of file ByteStreamEmonInputSvc.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ByteStreamEmonInputSvc()

Member Function Documentation

◆ check_publish()

◆ currentEvent()

◆ finalize()

◆ get_runparams()

◆ getIterator()

◆ initialize()

◆ nextEvent()

◆ previousEvent()

◆ start()

◆ updateHandler()

Member Data Documentation

◆ m_buffer_size

◆ m_clearHistograms

◆ m_connect

◆ m_convertEfficiency

◆ m_corrupted_events

◆ m_eventIt

◆ m_exclude

◆ m_exclude_rex

◆ m_exit

◆ m_frequency

◆ m_frequency_counter

◆ m_groupName

◆ m_histSvc

◆ m_include

◆ m_include_rex

◆ m_inputMetaDataStore

◆ m_is_server

◆ m_key

◆ m_key_count

◆ m_l1items

◆ m_l1logic

◆ m_l1MenuKey

◆ m_l1names

◆ m_l1origin

◆ m_partition

◆ m_provider

◆ m_publish

◆ m_publish_target

◆ m_re

◆ m_readDetectorMask

◆ m_robProvider

◆ m_sgSvc

◆ m_state

◆ m_stream_logic

◆ m_stream_names

◆ m_stream_type

◆ m_timeout

◆ m_totalEventCounter

◆ m_trigger_type

◆ m_updatePeriod

◆ m_updatePeriodRange

◆ m_value