ByteStreamEmonInputSvc Class Reference

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:
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	finalize () override
virtual const RawEvent *	previousEvent () override
	Implementation of the ByteStreamInputSvc interface methods.
virtual const RawEvent *	nextEvent () override
virtual const RawEvent *	currentEvent () const override
	Implementation of the ByteStreamInputSvc interface methods.

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
std::unique_ptr< RawEvent >	m_re {nullptr}
	current event
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::unique_ptr< emon::EventIterator >	m_eventIt
	Event iterator.
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 484 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);
                    if (!p)[[unlikely]] continue;
                    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 479 of file ByteStreamEmonInputSvc.cxx.

{
    return m_re.get();
}

finalize()

StatusCode ByteStreamEmonInputSvc::finalize ( )

overridevirtual

Definition at line 654 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 578 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,
                                     std::move(l1pattern),
                                     std::move(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 = std::make_unique<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 351 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
    CxxUtils::RefCountedPtr<ByteStreamAddress> iop
      (new ByteStreamAddress(ClassID_traits<xAOD::EventInfo>::ID(), "EventInfo", ""));
    StatusCode ioc = m_sgSvc->recordAddress("EventInfo",std::move(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
    CxxUtils::RefCountedPtr<ByteStreamAddress> iopaux
      (new ByteStreamAddress(ClassID_traits<xAOD::EventAuxInfo>::ID(), "EventInfoAux.", ""));
    StatusCode iocaux = m_sgSvc->recordAddress("EventInfoAux.",std::move(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 343 of file ByteStreamEmonInputSvc.cxx.

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

start()

StatusCode ByteStreamEmonInputSvc::start ( )

overridevirtual

Definition at line 618 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 644 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.

{this, "BufferSize", 2, "Number of buffers"};

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.

{this, "ClearHistograms", true, &ByteStreamEmonInputSvc::updateHandler, "If true, clear histograms when new run starts (default: True)"};

m_connect

bool ByteStreamEmonInputSvc::m_connect {false}

private

Definition at line 101 of file ByteStreamEmonInputSvc.h.

{false};

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.

{this, "ConvertEfficiency", true, "Convert TEfficiency to TProfile before publishing"};

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.

{this, "ProcessCorruptedEvents", false, &ByteStreamEmonInputSvc::updateHandler, "Process corrupted events not passing check_tree()"};

m_eventIt

std::unique_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.

{this, "Exclude", {}, &ByteStreamEmonInputSvc::updateHandler, "Regular expression to select histograms not to publish"};

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.

{this, "ExitOnPartitionShutdown", false, &ByteStreamEmonInputSvc::updateHandler, "If true, exit if partition shuts down"};

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.

{this, "Frequency", 60, &ByteStreamEmonInputSvc::updateHandler, "Frequency (in number of events) of publishing histograms"};

m_frequency_counter

int ByteStreamEmonInputSvc::m_frequency_counter {60}

private

Definition at line 109 of file ByteStreamEmonInputSvc.h.

{60};

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.

{this, "GroupName", {}, &ByteStreamEmonInputSvc::updateHandler, "Name of the monitoring group"};

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.

{this, "Include", {}, &ByteStreamEmonInputSvc::updateHandler, "Regular expression to select histograms to publish"};

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.

{this, "ISServer", "", &ByteStreamEmonInputSvc::updateHandler, "IS Server to publish histograms to"};

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.

{this, "Key", {}, &ByteStreamEmonInputSvc::updateHandler, "EMON Selection key, e.g. SFI"};

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.

{this, "KeyCount", 0, &ByteStreamEmonInputSvc::updateHandler, "EMON key count, e.g. 5 to get five random SFIs"};

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.

{this, "LVL1Items", {}, &ByteStreamEmonInputSvc::updateHandler, "A list of L1 bit numbers"};

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.

{this, "LVL1Logic", "Ignore", &ByteStreamEmonInputSvc::updateHandler, "'And', 'Or' or 'Ignore' (default: Ignore)"};

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.

{this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "Name of the L1Menu object to read configuration from"};

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.

{this, "LVL1Names", {}, &ByteStreamEmonInputSvc::updateHandler, "A list of L1 bit names"};

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.

{this, "LVL1Origin", "TAV", &ByteStreamEmonInputSvc::updateHandler, "TBP, TAP, TAV (default: TAV"};

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.

{this, "Partition", {}, "Partition name, default taken from $TDAQ_PARTITION if not set"};

m_provider

OHRootProvider* ByteStreamEmonInputSvc::m_provider {nullptr}

private

Definition at line 104 of file ByteStreamEmonInputSvc.h.

{nullptr};

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.

{this, "PublishName", "Athena", &ByteStreamEmonInputSvc::updateHandler, "Name under which to publish histograms"};

m_publish_target

int ByteStreamEmonInputSvc::m_publish_target {0}

private

Definition at line 110 of file ByteStreamEmonInputSvc.h.

{0};

m_re

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

private

current event

Definition at line 64 of file ByteStreamEmonInputSvc.h.

{nullptr};          

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.

{this, "ReadDetectorMaskFromIS", true, "Read detector mask from IS"};

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.

{this, "State", "None", "Read-only property showing the state"};

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.

{this, "StreamLogic", "Ignore", &ByteStreamEmonInputSvc::updateHandler, "'And', 'Or' or 'Ignore' (default: Ignore)"};

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.

{this, "StreamNames", {}, &ByteStreamEmonInputSvc::updateHandler, "List of HLT stream names"};

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.

{this, "StreamType", "physics", &ByteStreamEmonInputSvc::updateHandler, "HLT stream type (e.g. physics or calibration)"};

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.

{this, "Timeout", 3600000, &ByteStreamEmonInputSvc::updateHandler, "Timeout in seconds, -1 == infinity"};

m_totalEventCounter

int ByteStreamEmonInputSvc::m_totalEventCounter {0}

private

event Counter

Definition at line 62 of file ByteStreamEmonInputSvc.h.

{0}; 

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.

{this, "TriggerType", 256, &ByteStreamEmonInputSvc::updateHandler, "LVL1 8 bit trigger type"};

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.

{this, "UpdatePeriod", 0, &ByteStreamEmonInputSvc::updateHandler, "Frequency (in seconds) of publishing histograms"};

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.

{this, "UpdatePeriodRange", 0.2, "A percentage number to determine how close we have to be to the next update time to publish now"};

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.

{this, "KeyValue", {}, &ByteStreamEmonInputSvc::updateHandler, "EMON key values, e.g. [SFI-1, SFI-2]; if empty all SFIs"};

---

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

• ByteStreamEmonInputSvc.h
• ByteStreamEmonInputSvc.cxx