HLT online histogram service. More...

#include <WebdaqHistSvc.h>

Inheritance diagram for WebdaqHistSvc:

Collaboration diagram for WebdaqHistSvc:

Classes
struct	THistID
	Helper struct that bundles the histogram, name and mutex. More...

Public Member Functions
	WebdaqHistSvc (const std::string &name, ISvcLocator *svc)
virtual	~WebdaqHistSvc () noexcept override
virtual StatusCode initialize	ATLAS_NOT_THREAD_SAFE () override
virtual void	handle (const Incident &incident) override
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
virtual StatusCode	regHist (const std::string &name) override
virtual StatusCode	regHist (const std::string &name, std::unique_ptr< TH1 > hist) override
virtual StatusCode	regHist (const std::string &name, TH1 *) override
virtual StatusCode	getHist (const std::string &id, TH1 *&hist, size_t ind) const override
virtual StatusCode	getHist (const std::string &id, TH2 *&hist, size_t ind) const override
virtual StatusCode	getHist (const std::string &id, TH3 *&hist, size_t ind) const override
virtual StatusCode	deReg (TObject *obj) override
virtual StatusCode	deReg (const std::string &name) override
virtual std::vector< std::string >	getHists () const override
std::set< std::string >	getSet (boost::regex) const
virtual StatusCode	regShared (const std::string &, std::unique_ptr< TH1 >, LockedHandle< TH1 > &) override
virtual StatusCode	regShared (const std::string &, std::unique_ptr< TH2 >, LockedHandle< TH2 > &) override
virtual StatusCode	regShared (const std::string &, std::unique_ptr< TH3 >, LockedHandle< TH3 > &) override
virtual StatusCode	getShared (const std::string &, LockedHandle< TH1 > &) const override
virtual StatusCode	getShared (const std::string &, LockedHandle< TH2 > &) const override
virtual StatusCode	getShared (const std::string &, LockedHandle< TH3 > &) const override
virtual StatusCode	getTHists (TDirectory *td, TList &, bool recurse=false) const override
virtual StatusCode	getTHists (const std::string &name, TList &, bool recurse=false) const override
virtual StatusCode	getTHists (TDirectory *td, TList &tl, bool recurse=false, bool reg=false) override
virtual StatusCode	getTHists (const std::string &name, TList &tl, bool recurse=false, bool reg=false) override
virtual bool	exists (const std::string &name) const override
virtual bool	existsHist (const std::string &name) const override
virtual StatusCode	regTree (const std::string &) override
virtual StatusCode	regTree (const std::string &, std::unique_ptr< TTree >) override
virtual StatusCode	regTree (const std::string &, TTree *) override
virtual StatusCode	getTree (const std::string &, TTree *&) const override
virtual std::vector< std::string >	getTrees () const override
virtual StatusCode	getTTrees (TDirectory *, TList &, bool) const override
virtual StatusCode	getTTrees (const std::string &, TList &, bool) const override
virtual StatusCode	getTTrees (TDirectory *, TList &, bool, bool) override
virtual StatusCode	getTTrees (const std::string &, TList &, bool, bool) override
virtual StatusCode	regGraph (const std::string &) override
virtual StatusCode	regGraph (const std::string &, std::unique_ptr< TGraph >) override
virtual StatusCode	regGraph (const std::string &, TGraph *) override
virtual std::vector< std::string >	getGraphs () const override
virtual StatusCode	getGraph (const std::string &, TGraph *&) const override
virtual StatusCode	regEfficiency (const std::string &) override
virtual StatusCode	regEfficiency (const std::string &, std::unique_ptr< TEfficiency >) override
virtual StatusCode	regEfficiency (const std::string &, TEfficiency *) override
virtual StatusCode	getEfficiency (const std::string &, TEfficiency *&) const override
virtual std::vector< std::string >	getEfficiencies () const override
virtual StatusCode	getTEfficiencies (TDirectory *, TList &, bool) const override
virtual StatusCode	getTEfficiencies (const std::string &, TList &, bool) const override
virtual StatusCode	getTEfficiencies (TDirectory *, TList &, bool, bool) override
virtual StatusCode	getTEfficiencies (const std::string &, TList &, bool, bool) override
virtual StatusCode	regShared (const std::string &, std::unique_ptr< TGraph >, LockedHandle< TGraph > &) override
virtual StatusCode	getShared (const std::string &, LockedHandle< TGraph > &) const override
virtual StatusCode	regShared (const std::string &, std::unique_ptr< TEfficiency >, LockedHandle< TEfficiency > &) override
virtual StatusCode	getShared (const std::string &, LockedHandle< TEfficiency > &) const override
virtual StatusCode	merge (const std::string &) override
virtual StatusCode	merge (TObject *) override
virtual bool	existsTree (const std::string &) const override
virtual bool	existsGraph (const std::string &) const override
virtual bool	existsEfficiency (const std::string &) const override

Private Member Functions
void	monitoringTask (int, int, std::atomic< bool > &, boost::regex)
	The actual publication Task.
void	syncPublish (long int, boost::posix_time::ptime)
	Sync the publication to a multiple of the interval.
void	conditionedSleep (std::chrono::milliseconds, const std::atomic< bool > &)
	Sleep for a duration or until the stop flag is set.
bool	isObjectAllowed (const std::string &path, const TObject *o) const
	Does the histogram follow the naming rules ?
StatusCode	getTHists_i (const std::string &name, TList &) const
	Get TList of registered histograms.
template<typename T>
StatusCode	regHist_i (std::unique_ptr< T > hist, const std::string &name, bool shared, THistID *&phid)
template<typename T>
T *	getHist_i (const std::string &id, const size_t &ind, bool quiet=false) const
template<typename T>
LockedHandle< T >	regShared_i (const std::string &id, std::unique_ptr< T > hist)
template<typename T>
LockedHandle< T >	getShared_i (const std::string &id) const

Private Attributes
std::atomic< bool >	m_stopFlag {false}
	Flag to stop the monitoring task.
std::thread	m_thread
	Publication thread.
std::thread	m_threadFast
std::string	m_partition
	The partition to publish to.
std::string	m_tdaqWebdaqBase
	Webdaq configuration variable, see https://gitlab.cern.ch/atlas-tdaq-software/webdaq.
std::string	m_tdaqOHServerName
	The OH server name (TDAQ_OH_SERVER if defined, m_OHServerName otherwise).
std::atomic< bool >	m_histoMapUpdated {false}
	Flag to indicate when the histogram map is updated.
std::atomic< bool >	m_histoMapUpdatedFast {false}
	Flag to indicate when the histogram map is updated for the fast publication.
ServiceHandle< Gaudi::Interfaces::IOptionsSvc >	m_jobOptionsSvc {this, "JobOptionsSvc", "JobOptionsSvc"}
	joboptions service
tbb::concurrent_hash_map< std::string, THistID >	m_hists
	Map of the registered histograms.
Gaudi::Property< std::string >	m_excludeType {this, "ExcludeType", "()"}
Gaudi::Property< std::string >	m_includeType {this, "IncludeType", ".+"}
Gaudi::Property< std::string >	m_excludeName {this, "ExcludeName", ".\\.."}
Gaudi::Property< std::string >	m_includeName
Gaudi::Property< int >	m_numSlots {this, "NumSlots", 8, "Number of slots for the main monitoring task"}
Gaudi::Property< int >	m_numSlotsFast {this, "NumSlotsFast", 1, "Number of slots for the fast monitoring task"}
Gaudi::Property< int >	m_intervalSeconds {this, "IntervalSeconds", 80, "Interval between histogram publications periods in seconds"}
Gaudi::Property< int >	m_intervalSecondsFast {this, "IntervalSecondsFast", 10, "Interval between histogram publications periods in seconds for the fast publication"}
Gaudi::Property< std::string >	m_OHServerName {this, "OHServerName", "Histogramming", "Name of the OH server to publish histograms into"}
Gaudi::Property< std::string >	m_PublicationIncludeName {this, "PublicationIncludeName",".*","Regex to select histograms for publication"}
Gaudi::Property< std::string >	m_fastPublicationIncludeName {this, "FastPublicationIncludeName","^.EXPERT.HLTFramework.TrigSignatureMoni.*","Regex to select histograms for fast publication"}
Gaudi::Property< int >	m_autoSave {this, "AutoSave", 0, "Not supported by WebdaqHistSvc"}
Gaudi::Property< int >	m_autoFlush {this, "AutoFlush", 0, "Not supported by WebdaqHistSvc"}
Gaudi::Property< bool >	m_print {this, "PrintAll", false, "Not supported by WebdaqHistSvc"}
Gaudi::Property< int >	m_maxFileSize {this, "MaxFileSize", 10240, "Not supported by WebdaqHistSvc"}
Gaudi::Property< std::vector< std::string > >	m_outputfile {this, "Output", {}, "Not supported by WebdaqHistSvc"}
Gaudi::Property< std::vector< std::string > >	m_inputfile {this, "Input", {}, "Not supported by WebdaqHistSvc"}
boost::regex	m_excludeTypeRegex
boost::regex	m_includeTypeRegex
boost::regex	m_excludeNameRegex
boost::regex	m_includeNameRegex
boost::regex	m_PublicationIncludeNameRegex
boost::regex	m_fastPublicationIncludeNameRegex

Detailed Description

HLT online histogram service.

The main difference to the offline THistSvc are:

do not write any output ROOT files
support start/stop
only supports one histogram instance per name
publish histograms via webdaq The following environment variables are required:
TDAQ_WEBDAQ_BASE: should contain the protocol, hostname and, if required, the port number of webis_server to access. Example: http://localhost:8080
TDAQ_PARTITION: the partition to publish to

Definition at line 53 of file WebdaqHistSvc.h.

Constructor & Destructor Documentation

◆ WebdaqHistSvc()

WebdaqHistSvc::WebdaqHistSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Definition at line 34 of file WebdaqHistSvc.cxx.

34 : base_class(name, svc)

35{}

◆ ~WebdaqHistSvc()

virtual WebdaqHistSvc::~WebdaqHistSvc ( )

inlineoverridevirtualnoexcept

Definition at line 57 of file WebdaqHistSvc.h.

57{}

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

virtual StatusCode initialize WebdaqHistSvc::ATLAS_NOT_THREAD_SAFE ( )

overridevirtual

◆ conditionedSleep()

void WebdaqHistSvc::conditionedSleep	(	std::chrono::milliseconds	duration,
		const std::atomic< bool > &	stopFlag )

private

Sleep for a duration or until the stop flag is set.

Definition at line 671 of file WebdaqHistSvc.cxx.

                                                                                                    {
  auto start = std::chrono::steady_clock::now();
  while (true) {
    if (stopFlag.load()) {
      return;
    }
    auto elapsed = std::chrono::steady_clock::now() - start;
    if (elapsed >= duration) {
      break;
    }
    auto remaining = duration - std::chrono::duration_cast<std::chrono::milliseconds>(elapsed);
    std::this_thread::sleep_for(std::min(std::chrono::milliseconds(500), remaining));
  }
}

◆ deReg() [1/2]

StatusCode WebdaqHistSvc::deReg ( const std::string & name )

overridevirtual

Definition at line 318 of file WebdaqHistSvc.cxx.

{
  tbb::concurrent_hash_map<std::string, THistID>::accessor accessor;
  if (m_hists.find(accessor, id)) {
    //Delete the histogram
    accessor->second.obj->Delete();
    m_hists.erase(accessor);
    m_histoMapUpdated = true;
    m_histoMapUpdatedFast = true;
    ATH_MSG_DEBUG("Deregistration of " << id << " done");
    return StatusCode::SUCCESS;
  }
  ATH_MSG_ERROR("Deregistration failed: histogram with id \"" << id << "\" not found");
  return StatusCode::FAILURE;
}

◆ deReg() [2/2]

StatusCode WebdaqHistSvc::deReg ( TObject * obj )

overridevirtual

Definition at line 302 of file WebdaqHistSvc.cxx.

{
  // Find the relevant histogram and deregister it
  for (auto it = m_hists.begin(); it != m_hists.end(); ++it) {
    if (it->second.obj == optr) {
      ATH_MSG_DEBUG("Found histogram " << optr << " booked under " << it->first
                                       << " and will deregister it");
      return deReg(it->first);
    }
  }
  ATH_MSG_ERROR("Histogram with pointer " << optr << " not found in the histogram map");
  return StatusCode::FAILURE;
}

◆ exists()

virtual bool WebdaqHistSvc::exists ( const std::string & name ) const

inlineoverridevirtual

Definition at line 89 of file WebdaqHistSvc.h.

89{ return existsHist(name); }

WebdaqHistSvc::existsHist

virtual bool existsHist(const std::string &name) const override

Definition WebdaqHistSvc.cxx:393

◆ existsEfficiency()

virtual bool WebdaqHistSvc::existsEfficiency ( const std::string & ) const

inlineoverridevirtual

Definition at line 131 of file WebdaqHistSvc.h.

131{ NOSUPPORT(WARNING, "TEfficiency"); }

NOSUPPORT

#define NOSUPPORT(lvl, what)

Definition WebdaqHistSvc.h:33

◆ existsGraph()

virtual bool WebdaqHistSvc::existsGraph ( const std::string & ) const

inlineoverridevirtual

Definition at line 130 of file WebdaqHistSvc.h.

130{ NOSUPPORT(WARNING, "TGraph"); }

◆ existsHist()

bool WebdaqHistSvc::existsHist ( const std::string & name ) const

overridevirtual

Definition at line 393 of file WebdaqHistSvc.cxx.

{
  return (getHist_i<TH1>(name, 0, true) != nullptr);
}

◆ existsTree()

virtual bool WebdaqHistSvc::existsTree ( const std::string & ) const

inlineoverridevirtual

Definition at line 129 of file WebdaqHistSvc.h.

129{ NOSUPPORT(DEBUG, "TTree"); }

DEBUG

#define DEBUG

Definition page_access.h:11

◆ finalize()

StatusCode WebdaqHistSvc::finalize ( )

overridevirtual

Definition at line 143 of file WebdaqHistSvc.cxx.

{
  ATH_MSG_INFO("finalize");
  // Reset OH mutex
  oh_lock_histogram_mutex::reset_histogram_mutex();
 
  return StatusCode::SUCCESS;
}

◆ getEfficiencies()

virtual std::vector< std::string > WebdaqHistSvc::getEfficiencies ( ) const

inlineoverridevirtual

Definition at line 114 of file WebdaqHistSvc.h.

114{ NOSUPPORT(WARNING, "TEfficiency"); }

◆ getEfficiency()

virtual StatusCode WebdaqHistSvc::getEfficiency	(	const std::string &	,
		TEfficiency *&	) const

inlineoverridevirtual

Definition at line 113 of file WebdaqHistSvc.h.

113{ NOSUPPORT(WARNING, "TEfficiency"); }

◆ getGraph()

virtual StatusCode WebdaqHistSvc::getGraph	(	const std::string &	,
		TGraph *&	) const

inlineoverridevirtual

Definition at line 108 of file WebdaqHistSvc.h.

108{ NOSUPPORT(DEBUG, "TGraph"); }

◆ getGraphs()

virtual std::vector< std::string > WebdaqHistSvc::getGraphs ( ) const

inlineoverridevirtual

Definition at line 107 of file WebdaqHistSvc.h.

107{ NOSUPPORT(DEBUG, "TGraph"); }

◆ getHist() [1/3]

StatusCode WebdaqHistSvc::getHist	(	const std::string &	id,
		TH1 *&	hist,
		size_t	ind ) const

overridevirtual

Definition at line 424 of file WebdaqHistSvc.cxx.

{
  hist = getHist_i<TH1>(id, ind);
  return (hist != nullptr ? StatusCode::SUCCESS : StatusCode::FAILURE);
}

◆ getHist() [2/3]

StatusCode WebdaqHistSvc::getHist	(	const std::string &	id,
		TH2 *&	hist,
		size_t	ind ) const

overridevirtual

Definition at line 430 of file WebdaqHistSvc.cxx.

{
  hist = getHist_i<TH2>(id, ind);
  return (hist != nullptr ? StatusCode::SUCCESS : StatusCode::FAILURE);
}

◆ getHist() [3/3]

StatusCode WebdaqHistSvc::getHist	(	const std::string &	id,
		TH3 *&	hist,
		size_t	ind ) const

overridevirtual

Definition at line 436 of file WebdaqHistSvc.cxx.

{
  hist = getHist_i<TH3>(id, ind);
  return (hist != nullptr ? StatusCode::SUCCESS : StatusCode::FAILURE);
}

◆ getHist_i()

template<typename T>

T * WebdaqHistSvc::getHist_i	(	const std::string &	id,
		const size_t &	ind,
		bool	quiet = false ) const

private

Definition at line 236 of file WebdaqHistSvc.cxx.

{
  ATH_MSG_DEBUG("Getting histogram " << id);
 
  tbb::concurrent_hash_map<std::string, THistID>::const_accessor accessor;
  if (!m_hists.find(accessor, id) or accessor.empty()) {
    if (!quiet) ATH_MSG_ERROR("could not locate Hist with id \"" << id << "\"");
    return nullptr;
  }
 
  T* phist = dynamic_cast<T*>(accessor->second.obj);
  if (phist == nullptr) {
    ATH_MSG_ERROR("getHist: unable to dcast retrieved shared hist \""
                  << id << "\" of type " << accessor->second.obj->IsA()->GetName() << " to requested type "
                  << System::typeinfoName(typeid(T)));
    return nullptr;
  }
  return phist;
}

◆ getHists()

std::vector< std::string > WebdaqHistSvc::getHists ( ) const

overridevirtual

Definition at line 336 of file WebdaqHistSvc.cxx.

{
  std::vector<std::string> l;
  l.reserve(m_hists.size());
  for (auto it = m_hists.begin(); it != m_hists.end(); ++it) {
    l.push_back(it->first);
  }
  return l;
}

◆ getSet()

std::set< std::string > WebdaqHistSvc::getSet ( boost::regex nameSelect ) const

Definition at line 348 of file WebdaqHistSvc.cxx.

{
  std::vector<std::string> l;
  l.reserve(m_hists.size());
  for (auto it = m_hists.begin(); it != m_hists.end(); ++it) {
    if (boost::regex_match(it->first, nameSelect)) {
      l.push_back(it->first);
    }
  }
  ATH_MSG_DEBUG("Number of histograms matched: " << l.size());
  std::set<std::string> HistoSet(l.begin(), l.end());
  return HistoSet;
}

◆ getShared() [1/5]

virtual StatusCode WebdaqHistSvc::getShared	(	const std::string &	,
		LockedHandle< TEfficiency > &	) const

inlineoverridevirtual

Definition at line 124 of file WebdaqHistSvc.h.

124{ NOSUPPORT(WARNING, "TEfficiency"); }

◆ getShared() [2/5]

virtual StatusCode WebdaqHistSvc::getShared	(	const std::string &	,
		LockedHandle< TGraph > &	) const

inlineoverridevirtual

Definition at line 122 of file WebdaqHistSvc.h.

122{ NOSUPPORT(WARNING, "TGraph"); }

◆ getShared() [3/5]

StatusCode WebdaqHistSvc::getShared	(	const std::string &	id,
		LockedHandle< TH1 > &	lh ) const

overridevirtual

Definition at line 497 of file WebdaqHistSvc.cxx.

{
  lh = getShared_i<TH1>(id);
  return (lh ? StatusCode::SUCCESS : StatusCode::FAILURE);
}

◆ getShared() [4/5]

StatusCode WebdaqHistSvc::getShared	(	const std::string &	id,
		LockedHandle< TH2 > &	lh ) const

overridevirtual

Definition at line 503 of file WebdaqHistSvc.cxx.

{
  lh = getShared_i<TH2>(id);
  return (lh ? StatusCode::SUCCESS : StatusCode::FAILURE);
}

◆ getShared() [5/5]

StatusCode WebdaqHistSvc::getShared	(	const std::string &	id,
		LockedHandle< TH3 > &	lh ) const

overridevirtual

Definition at line 509 of file WebdaqHistSvc.cxx.

{
  lh = getShared_i<TH3>(id);
  return (lh ? StatusCode::SUCCESS : StatusCode::FAILURE);
}

◆ getShared_i()

template<typename T>

LockedHandle< T > WebdaqHistSvc::getShared_i ( const std::string & id ) const

private

Definition at line 273 of file WebdaqHistSvc.cxx.

{
  tbb::concurrent_hash_map<std::string, THistID>::const_accessor accessor;
  if (m_hists.find(accessor, id)) {
    //coverity[FORWARD_NULL]
    auto * obj = accessor->second.obj;
    //accessor is implicitly valid
    //coverity[FORWARD_NULL]
    if (accessor->second.mutex == nullptr) {
      ATH_MSG_ERROR("getShared: found Hist with id \"" << id
                                                       << "\", but it's not marked as shared");
      return {};
    }  
    T* phist = dynamic_cast<T*>(obj);
    if (phist == nullptr) {
      const char* gotType = obj ? obj->IsA()->GetName() : "<null>";
      ATH_MSG_ERROR("getShared: unable to dcast retrieved shared hist \""
                    << id << "\" of type " << gotType
                    << " to requested type " << System::typeinfoName(typeid(T)));
      return {};
    }
    return LockedHandle<T>(phist, accessor->second.mutex.get());
  }
  ATH_MSG_ERROR("getShared: cannot find histogram with id \"" << id << "\"");
  return {};
}

◆ getTEfficiencies() [1/4]

virtual StatusCode WebdaqHistSvc::getTEfficiencies	(	const std::string &	,
		TList &	,
		bool	) const

inlineoverridevirtual

Definition at line 117 of file WebdaqHistSvc.h.

117{ NOSUPPORT(WARNING, "TEfficiency"); }

◆ getTEfficiencies() [2/4]

virtual StatusCode WebdaqHistSvc::getTEfficiencies	(	const std::string &	,
		TList &	,
		bool	,
		bool	)

inlineoverridevirtual

Definition at line 119 of file WebdaqHistSvc.h.

119{ NOSUPPORT(WARNING, "TEfficiency"); }

◆ getTEfficiencies() [3/4]

virtual StatusCode WebdaqHistSvc::getTEfficiencies	(	TDirectory *	,
		TList &	,
		bool	) const

inlineoverridevirtual

Definition at line 116 of file WebdaqHistSvc.h.

116{ NOSUPPORT(WARNING, "TEfficiency"); }

◆ getTEfficiencies() [4/4]

virtual StatusCode WebdaqHistSvc::getTEfficiencies	(	TDirectory *	,
		TList &	,
		bool	,
		bool	)

inlineoverridevirtual

Definition at line 118 of file WebdaqHistSvc.h.

118{ NOSUPPORT(WARNING, "TEfficiency"); }

◆ getTHists() [1/4]

StatusCode WebdaqHistSvc::getTHists	(	const std::string &	name,
		TList &	tl,
		bool	recurse = false ) const

overridevirtual

Definition at line 450 of file WebdaqHistSvc.cxx.

{
  if (recurse) ATH_MSG_DEBUG("Recursive flag is not supported in this implementation");
  return getTHists_i(dir, tl);
}

◆ getTHists() [2/4]

StatusCode WebdaqHistSvc::getTHists	(	const std::string &	name,
		TList &	tl,
		bool	recurse = false,
		bool	reg = false )

overridevirtual

Definition at line 464 of file WebdaqHistSvc.cxx.

{
  if (recurse || reg)
    ATH_MSG_DEBUG("Recursive flag and automatic registration flag is not "
                  "supported in this implementation");
  return getTHists_i(dir, tl);
}

◆ getTHists() [3/4]

StatusCode WebdaqHistSvc::getTHists	(	TDirectory *	td,
		TList &	tl,
		bool	recurse = false ) const

overridevirtual

Definition at line 444 of file WebdaqHistSvc.cxx.

{
  if (recurse) ATH_MSG_DEBUG("Recursive flag is not supported in this implementation");
  return getTHists_i(std::string(td->GetPath()), tl);
}

◆ getTHists() [4/4]

StatusCode WebdaqHistSvc::getTHists	(	TDirectory *	td,
		TList &	tl,
		bool	recurse = false,
		bool	reg = false )

overridevirtual

Definition at line 456 of file WebdaqHistSvc.cxx.

{
  if (recurse || reg)
    ATH_MSG_DEBUG("Recursive flag and automatic registration flag is not "
                  "supported in this implementation");
  return getTHists_i(std::string(td->GetPath()), tl);
}

◆ getTHists_i()

StatusCode WebdaqHistSvc::getTHists_i	(	const std::string &	name,
		TList &	tl ) const

private

Get TList of registered histograms.

Definition at line 258 of file WebdaqHistSvc.cxx.

{
  for (auto it = m_hists.begin(); it != m_hists.end(); ++it) {
    const std::string& id = it->first;
    const THistID& h = it->second;
    if (id.starts_with(dir)) { // histogram booking path starts from the dir
      tl.Add(h.obj);
    }
  }
  return StatusCode::SUCCESS;
}

◆ getTree()

virtual StatusCode WebdaqHistSvc::getTree	(	const std::string &	,
		TTree *&	) const

inlineoverridevirtual

Definition at line 96 of file WebdaqHistSvc.h.

96{ NOSUPPORT(WARNING, "TTree"); }

◆ getTrees()

virtual std::vector< std::string > WebdaqHistSvc::getTrees ( ) const

inlineoverridevirtual

Definition at line 98 of file WebdaqHistSvc.h.

98{ NOSUPPORT(DEBUG, "TTree"); }

◆ getTTrees() [1/4]

virtual StatusCode WebdaqHistSvc::getTTrees	(	const std::string &	,
		TList &	,
		bool	) const

inlineoverridevirtual

Definition at line 100 of file WebdaqHistSvc.h.

100{ NOSUPPORT(DEBUG, "TTree"); }

◆ getTTrees() [2/4]

virtual StatusCode WebdaqHistSvc::getTTrees	(	const std::string &	,
		TList &	,
		bool	,
		bool	)

inlineoverridevirtual

Definition at line 102 of file WebdaqHistSvc.h.

102{ NOSUPPORT(DEBUG, "TTree"); }

◆ getTTrees() [3/4]

virtual StatusCode WebdaqHistSvc::getTTrees	(	TDirectory *	,
		TList &	,
		bool	) const

inlineoverridevirtual

Definition at line 99 of file WebdaqHistSvc.h.

99{ NOSUPPORT(DEBUG, "TTree"); }

◆ getTTrees() [4/4]

virtual StatusCode WebdaqHistSvc::getTTrees	(	TDirectory *	,
		TList &	,
		bool	,
		bool	)

inlineoverridevirtual

Definition at line 101 of file WebdaqHistSvc.h.

101{ NOSUPPORT(DEBUG, "TTree"); }

◆ handle()

void WebdaqHistSvc::handle ( const Incident & incident )

overridevirtual

Definition at line 97 of file WebdaqHistSvc.cxx.

{
  if (incident.type() == AthenaInterprocess::UpdateAfterFork::type()) {
    ATH_MSG_INFO("Going to initialize the monitoring Thread"); 
    m_thread = std::thread( &WebdaqHistSvc::monitoringTask, this, m_numSlots, m_intervalSeconds, std::ref(m_histoMapUpdated), m_PublicationIncludeNameRegex);
    m_threadFast = std::thread( &WebdaqHistSvc::monitoringTask, this, m_numSlotsFast, m_intervalSecondsFast, std::ref(m_histoMapUpdatedFast), m_fastPublicationIncludeNameRegex);
  }
}

◆ isObjectAllowed()

bool WebdaqHistSvc::isObjectAllowed	(	const std::string &	path,
		const TObject *	o ) const

private

Does the histogram follow the naming rules ?

Definition at line 364 of file WebdaqHistSvc.cxx.

{
  boost::cmatch what;
 
  if (not boost::regex_match(o->ClassName(), what, m_includeTypeRegex)) {
    ATH_MSG_WARNING("Object " << path << " of type " << o->ClassName()
                              << " does NOT match IncludeType \"" << m_includeType << "\"");
    return false;
  }
 
  if (boost::regex_match(o->ClassName(), what, m_excludeTypeRegex)) {
    ATH_MSG_WARNING("Object " << path << " of type " << o->ClassName() << " matches ExcludeType \""
                              << m_excludeType << "\"");
    return false;
  }
 
  if (not boost::regex_match(path.c_str(), what, m_includeNameRegex)) {
    ATH_MSG_WARNING("Object " << path << " does NOT match IncludeName \"" << m_includeName << "\"");
    return false;
  }
 
  if (boost::regex_match(path.c_str(), what, m_excludeNameRegex)) {
    ATH_MSG_WARNING("Object " << path << " matches ExcludeName \"" << m_excludeName << "\"");
    return false;
  }
 
  return true;
}

◆ merge() [1/2]

virtual StatusCode WebdaqHistSvc::merge ( const std::string & )

inlineoverridevirtual

Definition at line 126 of file WebdaqHistSvc.h.

126{ NOSUPPORT(WARNING, "merge"); }

◆ merge() [2/2]

virtual StatusCode WebdaqHistSvc::merge ( TObject * )

inlineoverridevirtual

Definition at line 127 of file WebdaqHistSvc.h.

127{ NOSUPPORT(WARNING, "merge"); }

◆ monitoringTask()

void WebdaqHistSvc::monitoringTask	(	int	numSlots,
		int	intervalSeconds,
		std::atomic< bool > &	histoMapUpdated,
		boost::regex	nameSelect )

private

The actual publication Task.

Histograms publication via WebDAQ.

It divides the histograms into batches and publishes them in slots. The method also handles synchronization to ensure that the publication happens at regular intervals.

Parameters

numSlots	Number of slots to divide the histograms into for publication.
intervalSeconds	Interval in seconds between each publication cycle.
histoMapUpdated	Atomic flag indicating if the histogram map has been updated.
nameSelect	Regular expression to select histograms for publication.

Definition at line 527 of file WebdaqHistSvc.cxx.

{
  ATH_MSG_INFO("Started monitoring task for partition: " << m_partition << "and regex: " << nameSelect.str());
  std::string appName = m_jobOptionsSvc->get("DataFlowConfig.DF_ApplicationName");
  // OH doesn't allow multiple providers for a given server
  // Need to modify the path for one of the threads to avoid the issue
  if (nameSelect != boost::regex(".*"))
    appName = appName + "_fast";
  
  // Set the publication period
  boost::posix_time::time_duration interval{boost::posix_time::seconds(intervalSeconds)};
  ATH_MSG_DEBUG("Interval set to " << interval.total_seconds() << " seconds");
  int interval_ms = interval.total_milliseconds();
  if(numSlots == 0) numSlots = 1;
  boost::posix_time::ptime epoch(boost::gregorian::date(2024,1,1)); 
  // Sleep duration between slots (plus an extra slot for allowing a last sleep cycle)
  boost::posix_time::time_duration slotSleepDuration = interval / (numSlots + 1);
 
  // Create the Set of the histograms keys to order the histograms publication and reset the histoMapUpdated flag 
  std::set<std::string> HistoSet = getSet(nameSelect);
  histoMapUpdated = false;
 
  // Sync the publication to the period
  syncPublish(interval_ms, epoch);
  ATH_MSG_DEBUG("Monitoring task synched");
 
  // Publication loop
  while (!m_stopFlag) 
  {
    // Check if the histograms map has been updated, and if so update the Set
    if (histoMapUpdated)
    {
      ATH_MSG_DEBUG("Histo map updated, updating the Set");
      HistoSet = getSet(nameSelect);
      histoMapUpdated = false;
    }
    size_t totalHists = HistoSet.size();
    ATH_MSG_DEBUG("Going to publish " << totalHists << " histograms");
 
    // Divide the histograms in batches
    size_t batchSize = (totalHists + numSlots - 1) / numSlots; // Ceiling division
    ATH_MSG_DEBUG("Num of slots:" << numSlots << ", Interval_ms " << interval_ms << " milliseconds, Batch size: " << batchSize);
 
    boost::posix_time::ptime start_time = boost::posix_time::microsec_clock::universal_time();
    int counter = 0;
    int BatchCounter = 0;
    auto it = HistoSet.begin();
    while(it != HistoSet.end())
    {
      boost::posix_time::ptime slot_start_time = boost::posix_time::microsec_clock::universal_time();
      //Batch publication
      ATH_MSG_DEBUG("Batch publication number " << BatchCounter << "  starting.");
      for(size_t j = 0; j < batchSize; ++j)
      {
        if(it == HistoSet.end())
        {
          break;
        }
        const std::string& id = *it;
        std::string path = appName + '.' + id;
        ATH_MSG_DEBUG("Publishing to " << m_partition << " Histogram " << path << " to the OH server " << m_tdaqOHServerName);
        tbb::concurrent_hash_map<std::string, THistID>::const_accessor accessor;
        if (!m_hists.find(accessor, id)) {
          ATH_MSG_WARNING("Histogram with name " << id << " not found in histogram map (probably deregistered).");
          it++;
          continue;
        }
        else
        {
          ATH_MSG_DEBUG("Histogram found in map, going to lock mutex and then publish it");
          //Here we clone the histogram to avoid locking the OH mutex during the whole publication 
          TObject* obj = nullptr;
          {
            //Locking the OH mutex before touching the Histogram
            oh_scoped_lock_histogram lock;
            //accessor is implicitly valid
            //coverity[FORWARD_NULL]
            obj = accessor->second.obj->Clone(); 
          }
          if (obj == nullptr) {
            ATH_MSG_ERROR("Failed to clone histogram " << id);
            it++;
            continue;
          }
          if (!webdaq::oh::put(m_partition, m_tdaqOHServerName, path, obj)) {
            ATH_MSG_ERROR("Histogram publishing failed !");
          }
          //Delete the cloned histogram. This was creating a memory leak
          ATH_MSG_DEBUG("Deleting cloned histogram");
          delete obj;
        }
        it++;
        counter++;
      } 
      ATH_MSG_DEBUG("Batch publication completed, " << counter << " histograms published");
      // Sleep for slotSleepDuration - slot publication time, unless it's the last slot
      if (it != HistoSet.end()) {
        boost::posix_time::ptime slot_end_time = boost::posix_time::microsec_clock::universal_time();
        int slot_sleep_time = slotSleepDuration.total_milliseconds() - (slot_end_time-slot_start_time).total_milliseconds();
        if (slot_sleep_time > 0) {
          ATH_MSG_DEBUG("Sleeping for " << slot_sleep_time << " seconds before publishing the next batch");
          conditionedSleep(std::chrono::milliseconds(slot_sleep_time), m_stopFlag);
        }
      }
      BatchCounter++;
    }
 
    //check if we exceeded the publication period
    boost::posix_time::ptime end_time = boost::posix_time::microsec_clock::universal_time();
    if (boost::posix_time::time_duration(end_time-start_time) > interval) {
      ATH_MSG_WARNING("Publication deadline missed, cycle exceeded the interval.. Total publication time " 
      <<  boost::posix_time::to_simple_string(end_time-start_time));
    }
    ATH_MSG_DEBUG("Completed the publication of " << counter << " histograms. Publication time: " << boost::posix_time::to_simple_string(end_time-start_time));
 
    //sleep till the next cycle
    boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time(); 
    int nowMs = (now-epoch).total_milliseconds();
    boost::posix_time::time_duration next_cycle(boost::posix_time::milliseconds(interval_ms - (nowMs % interval_ms)));
    ATH_MSG_DEBUG("epoch " << epoch);
    ATH_MSG_DEBUG("interval_ms" << interval_ms);
    ATH_MSG_DEBUG("now_ms " << nowMs);
    ATH_MSG_DEBUG("Sleeping for " << next_cycle.total_milliseconds() << " milliseconds till the next cycle");
    conditionedSleep(std::chrono::milliseconds(next_cycle.total_milliseconds()), m_stopFlag);
  }
  ATH_MSG_INFO("Monitoring task stopped");
}

◆ regEfficiency() [1/3]

virtual StatusCode WebdaqHistSvc::regEfficiency ( const std::string & )

inlineoverridevirtual

Definition at line 110 of file WebdaqHistSvc.h.

110{ NOSUPPORT(WARNING, "TEfficiency"); }

◆ regEfficiency() [2/3]

virtual StatusCode WebdaqHistSvc::regEfficiency	(	const std::string &	,
		std::unique_ptr< TEfficiency >	)

inlineoverridevirtual

Definition at line 111 of file WebdaqHistSvc.h.

111{ NOSUPPORT(WARNING, "TEfficiency"); }

◆ regEfficiency() [3/3]

virtual StatusCode WebdaqHistSvc::regEfficiency	(	const std::string &	,
		TEfficiency *	)

inlineoverridevirtual

Definition at line 112 of file WebdaqHistSvc.h.

112{ NOSUPPORT(WARNING, "TEfficiency"); }

◆ regGraph() [1/3]

virtual StatusCode WebdaqHistSvc::regGraph ( const std::string & )

inlineoverridevirtual

Definition at line 104 of file WebdaqHistSvc.h.

104{ NOSUPPORT(WARNING, "TGraph"); }

◆ regGraph() [2/3]

virtual StatusCode WebdaqHistSvc::regGraph	(	const std::string &	,
		std::unique_ptr< TGraph >	)

inlineoverridevirtual

Definition at line 105 of file WebdaqHistSvc.h.

105{ NOSUPPORT(WARNING, "TGraph"); }

◆ regGraph() [3/3]

virtual StatusCode WebdaqHistSvc::regGraph	(	const std::string &	,
		TGraph *	)

inlineoverridevirtual

Definition at line 106 of file WebdaqHistSvc.h.

106{ NOSUPPORT(WARNING, "TGraph"); }

◆ regHist() [1/3]

StatusCode WebdaqHistSvc::regHist ( const std::string & name )

overridevirtual

Definition at line 402 of file WebdaqHistSvc.cxx.

{
  std::unique_ptr<TH1> hist = nullptr;
  THistID* hid = nullptr;
  return regHist_i(std::move(hist), id, false, hid);
}

◆ regHist() [2/3]

StatusCode WebdaqHistSvc::regHist	(	const std::string &	name,
		std::unique_ptr< TH1 >	hist )

overridevirtual

Definition at line 409 of file WebdaqHistSvc.cxx.

{
  THistID* hid = nullptr;
  return regHist_i(std::move(hist), id, false, hid);
}

◆ regHist() [3/3]

StatusCode WebdaqHistSvc::regHist	(	const std::string &	name,
		TH1 *	hist_ptr )

overridevirtual

Definition at line 415 of file WebdaqHistSvc.cxx.

{
  THistID* hid = nullptr;
  std::unique_ptr<TH1> hist(hist_ptr);
  return regHist_i(std::move(hist), id, false, hid);
}

◆ regHist_i()

template<typename T>

StatusCode WebdaqHistSvc::regHist_i	(	std::unique_ptr< T >	hist,
		const std::string &	name,
		bool	shared,
		THistID *&	phid )

private

Definition at line 155 of file WebdaqHistSvc.cxx.

{
  ATH_MSG_DEBUG("Registering histogram " << id);
 
  phid = nullptr;
  if (not isObjectAllowed(id, hist_unique.get())) {
    return StatusCode::FAILURE;
  }
 
  if (hist_unique->Class()->InheritsFrom(TH1::Class())) {
    
    tbb::concurrent_hash_map<std::string, THistID>::accessor accessor;
    if (m_hists.find(accessor, id)) {
      ATH_MSG_ERROR("Histogram with name " << id << " already registered");
      return StatusCode::FAILURE; 
    } 
    // Element not found, attempt to insert
    if (!m_hists.insert(accessor, id)) {
      ATH_MSG_ERROR("Failed to insert histogram with name " << id);
      return StatusCode::FAILURE;
    }
    T* hist = hist_unique.release();
    m_histoMapUpdated = true;
    m_histoMapUpdatedFast = true;
    accessor->second = THistID(id, hist);
    //finished
    if (shared) accessor->second.mutex = std::make_unique<std::mutex>();
    phid = &accessor->second;
    ATH_MSG_DEBUG((shared ? "Shared histogram " : "Histogram ")
          << hist->GetName() << " registered under " << id << " " << name());
  } else {
    ATH_MSG_ERROR("Cannot register " << hist_unique->ClassName()
                                     << " because it does not inherit from TH1");
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

◆ regShared() [1/5]

virtual StatusCode WebdaqHistSvc::regShared	(	const std::string &	,
		std::unique_ptr< TEfficiency >	,
		LockedHandle< TEfficiency > &	)

inlineoverridevirtual

Definition at line 123 of file WebdaqHistSvc.h.

123{ NOSUPPORT(WARNING, "TEfficiency"); }

◆ regShared() [2/5]

virtual StatusCode WebdaqHistSvc::regShared	(	const std::string &	,
		std::unique_ptr< TGraph >	,
		LockedHandle< TGraph > &	)

inlineoverridevirtual

Definition at line 121 of file WebdaqHistSvc.h.

121{ NOSUPPORT(WARNING, "TGraph"); }

◆ regShared() [3/5]

StatusCode WebdaqHistSvc::regShared	(	const std::string &	id,
		std::unique_ptr< TH1 >	hist,
		LockedHandle< TH1 > &	lh )

overridevirtual

Definition at line 474 of file WebdaqHistSvc.cxx.

{
  lh = regShared_i<TH1>(id, std::move(hist));
  return (lh ? StatusCode::SUCCESS : StatusCode::FAILURE);
}

◆ regShared() [4/5]

StatusCode WebdaqHistSvc::regShared	(	const std::string &	id,
		std::unique_ptr< TH2 >	hist,
		LockedHandle< TH2 > &	lh )

overridevirtual

Definition at line 481 of file WebdaqHistSvc.cxx.

{
  lh = regShared_i<TH2>(id, std::move(hist));
  return (lh ? StatusCode::SUCCESS : StatusCode::FAILURE);
}

◆ regShared() [5/5]

StatusCode WebdaqHistSvc::regShared	(	const std::string &	id,
		std::unique_ptr< TH3 >	hist,
		LockedHandle< TH3 > &	lh )

overridevirtual

Definition at line 488 of file WebdaqHistSvc.cxx.

{
  lh = regShared_i<TH3>(id, std::move(hist));
  return (lh ? StatusCode::SUCCESS : StatusCode::FAILURE);
}

◆ regShared_i()

template<typename T>

LockedHandle< T > WebdaqHistSvc::regShared_i	(	const std::string &	id,
		std::unique_ptr< T >	hist )

private

Definition at line 197 of file WebdaqHistSvc.cxx.

{
  LockedHandle<T> lh(nullptr, nullptr);
  
  tbb::concurrent_hash_map<std::string, THistID>::accessor accessor;
  // Check if the histogram is already registered
  if (!m_hists.find(accessor, id)) {
    // No histogram under that id yet
    T* phist = hist.get();
    THistID* phid = nullptr;
    if (regHist_i(std::move(hist), id, true, phid).isSuccess()) {
      if (phid) lh.set(phist, phid->mutex.get());
    }
  }
  else 
  {
    // Histogram already registered under that id
    if (accessor->second.mutex == nullptr) {
      ATH_MSG_ERROR("regShared: previously registered histogram \"" << id
                                                                    << "\" was not marked shared");
    }
    T* phist = dynamic_cast<T*>(accessor->second.obj);
    if (phist == nullptr) {
      ATH_MSG_ERROR("regShared: unable to dcast retrieved shared hist \""
                    << id << "\" of type " << accessor->second.obj->IsA()->GetName()
                    << " to requested type " << System::typeinfoName(typeid(T)));
    }
    else {
      lh.set(phist, accessor->second.mutex.get());
      //hist is automatically deleted at end of method
    }
  }
  return lh;
}

◆ regTree() [1/3]

virtual StatusCode WebdaqHistSvc::regTree ( const std::string & )

inlineoverridevirtual

Definition at line 93 of file WebdaqHistSvc.h.

93{ NOSUPPORT(WARNING, "TTree"); }

◆ regTree() [2/3]

virtual StatusCode WebdaqHistSvc::regTree	(	const std::string &	,
		std::unique_ptr< TTree >	)

inlineoverridevirtual

Definition at line 94 of file WebdaqHistSvc.h.

94{ NOSUPPORT(WARNING, "TTree"); }

◆ regTree() [3/3]

virtual StatusCode WebdaqHistSvc::regTree	(	const std::string &	,
		TTree *	)

inlineoverridevirtual

Definition at line 95 of file WebdaqHistSvc.h.

95{ NOSUPPORT(WARNING, "TTree"); }

◆ stop()

StatusCode WebdaqHistSvc::stop ( )

overridevirtual

Set the stop flag for the task thread to true

Definition at line 108 of file WebdaqHistSvc.cxx.

{
  ATH_MSG_DEBUG("Stopping monitoring task");
  m_stopFlag = true; 
  // Wait for the task to finish
  if (m_thread.joinable()) {
    ATH_MSG_DEBUG("Going to join the monitoring thread");
    try {
        m_thread.join();
    } 
    catch (const std::exception& e) {
      ATH_MSG_ERROR("Failed to join the monitoring thread: " << e.what());
      return StatusCode::FAILURE;
    }
  }
  if (m_threadFast.joinable()) {
    ATH_MSG_DEBUG("Going to join the fast monitoring thread");
    try {
        m_threadFast.join();
    } 
    catch (const std::exception& e) {
      ATH_MSG_ERROR("Failed to join the fast monitoring thread: " << e.what());
      return StatusCode::FAILURE;
    }
  }
  ATH_MSG_DEBUG("Clearing list of histograms");
  m_hists.clear();
  m_histoMapUpdated = true;
  m_histoMapUpdatedFast = true;
  return StatusCode::SUCCESS;
}

◆ syncPublish()

void WebdaqHistSvc::syncPublish	(	long int	interval_ms,
		boost::posix_time::ptime	epoch )

private

Sync the publication to a multiple of the interval.

Definition at line 657 of file WebdaqHistSvc.cxx.

{
  //Sync the publication to a multple of the interval
  //Code taken from TDAQ monsvc https://gitlab.cern.ch/atlas-tdaq-software/monsvc/-/blob/master/src/PeriodicScheduler.cxx?ref_type=heads#L163
  boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();
  int now_ms = (now-epoch).total_milliseconds();
  //If now_ms % interval_ms == 0 we skip a cycle. Too bad.
  boost::posix_time::time_duration sync(boost::posix_time::milliseconds(interval_ms - (now_ms % interval_ms)));
  //Do not sync if we are below 50 ms
  if (sync.total_milliseconds() > 50){
    std::this_thread::sleep_for(std::chrono::milliseconds(sync.total_milliseconds()));
  } 
}

Member Data Documentation

◆ m_autoFlush

Gaudi::Property<int> WebdaqHistSvc::m_autoFlush {this, "AutoFlush", 0, "Not supported by WebdaqHistSvc"}

private

Definition at line 201 of file WebdaqHistSvc.h.

201{this, "AutoFlush", 0, "Not supported by WebdaqHistSvc"};

◆ m_autoSave

Gaudi::Property<int> WebdaqHistSvc::m_autoSave {this, "AutoSave", 0, "Not supported by WebdaqHistSvc"}

private

Definition at line 200 of file WebdaqHistSvc.h.

200{this, "AutoSave", 0, "Not supported by WebdaqHistSvc"};

◆ m_excludeName

Gaudi::Property<std::string> WebdaqHistSvc::m_excludeName {this, "ExcludeName", ".*\\..*"}

private

Definition at line 186 of file WebdaqHistSvc.h.

186{this, "ExcludeName", ".*\\..*"};

◆ m_excludeNameRegex

boost::regex WebdaqHistSvc::m_excludeNameRegex

private

Definition at line 210 of file WebdaqHistSvc.h.

◆ m_excludeType

Gaudi::Property<std::string> WebdaqHistSvc::m_excludeType {this, "ExcludeType", "()"}

private

Definition at line 184 of file WebdaqHistSvc.h.

184{this, "ExcludeType", "()"};

◆ m_excludeTypeRegex

boost::regex WebdaqHistSvc::m_excludeTypeRegex

private

Definition at line 208 of file WebdaqHistSvc.h.

◆ m_fastPublicationIncludeName

Gaudi::Property<std::string> WebdaqHistSvc::m_fastPublicationIncludeName {this, "FastPublicationIncludeName","^.EXPERT.HLTFramework.TrigSignatureMoni.*","Regex to select histograms for fast publication"}

private

Definition at line 197 of file WebdaqHistSvc.h.

197{this, "FastPublicationIncludeName","^.EXPERT.HLTFramework.TrigSignatureMoni.*","Regex to select histograms for fast publication"};

◆ m_fastPublicationIncludeNameRegex

boost::regex WebdaqHistSvc::m_fastPublicationIncludeNameRegex

private

Definition at line 213 of file WebdaqHistSvc.h.

◆ m_histoMapUpdated

std::atomic<bool> WebdaqHistSvc::m_histoMapUpdated {false}

private

Flag to indicate when the histogram map is updated.

Definition at line 161 of file WebdaqHistSvc.h.

161{false};

◆ m_histoMapUpdatedFast

std::atomic<bool> WebdaqHistSvc::m_histoMapUpdatedFast {false}

private

Flag to indicate when the histogram map is updated for the fast publication.

Definition at line 163 of file WebdaqHistSvc.h.

163{false};

◆ m_hists

tbb::concurrent_hash_map<std::string, THistID> WebdaqHistSvc::m_hists

private

Map of the registered histograms.

Definition at line 169 of file WebdaqHistSvc.h.

◆ m_includeName

Gaudi::Property<std::string> WebdaqHistSvc::m_includeName

private

Initial value:

{this, "IncludeName",

"^/((run_[0-9]+/lb_[0-9]+/LB)|(SHIFT)|(EXPERT)|(DEBUG)|(EXPRESS)|(RUNSTAT))/.+/.+"}

Definition at line 187 of file WebdaqHistSvc.h.

187 {this, "IncludeName",

188 "^/((run_[0-9]+/lb_[0-9]+/LB)|(SHIFT)|(EXPERT)|(DEBUG)|(EXPRESS)|(RUNSTAT))/.+/.+"};

◆ m_includeNameRegex

boost::regex WebdaqHistSvc::m_includeNameRegex

private

Definition at line 211 of file WebdaqHistSvc.h.

◆ m_includeType

Gaudi::Property<std::string> WebdaqHistSvc::m_includeType {this, "IncludeType", ".+"}

private

Definition at line 185 of file WebdaqHistSvc.h.

185{this, "IncludeType", ".+"};

◆ m_includeTypeRegex

boost::regex WebdaqHistSvc::m_includeTypeRegex

private

Definition at line 209 of file WebdaqHistSvc.h.

◆ m_inputfile

Gaudi::Property<std::vector<std::string> > WebdaqHistSvc::m_inputfile {this, "Input", {}, "Not supported by WebdaqHistSvc"}

private

Definition at line 205 of file WebdaqHistSvc.h.

205{this, "Input", {}, "Not supported by WebdaqHistSvc"};

◆ m_intervalSeconds

Gaudi::Property<int> WebdaqHistSvc::m_intervalSeconds {this, "IntervalSeconds", 80, "Interval between histogram publications periods in seconds"}

private

Definition at line 193 of file WebdaqHistSvc.h.

193{this, "IntervalSeconds", 80, "Interval between histogram publications periods in seconds"};

◆ m_intervalSecondsFast

Gaudi::Property<int> WebdaqHistSvc::m_intervalSecondsFast {this, "IntervalSecondsFast", 10, "Interval between histogram publications periods in seconds for the fast publication"}

private

Definition at line 194 of file WebdaqHistSvc.h.

194{this, "IntervalSecondsFast", 10, "Interval between histogram publications periods in seconds for the fast publication"};

◆ m_jobOptionsSvc

ServiceHandle<Gaudi::Interfaces::IOptionsSvc> WebdaqHistSvc::m_jobOptionsSvc {this, "JobOptionsSvc", "JobOptionsSvc"}

private

joboptions service

Definition at line 166 of file WebdaqHistSvc.h.

166{this, "JobOptionsSvc", "JobOptionsSvc"};

◆ m_maxFileSize

Gaudi::Property<int> WebdaqHistSvc::m_maxFileSize {this, "MaxFileSize", 10240, "Not supported by WebdaqHistSvc"}

private

Definition at line 203 of file WebdaqHistSvc.h.

203{this, "MaxFileSize", 10240, "Not supported by WebdaqHistSvc"};

◆ m_numSlots

Gaudi::Property<int> WebdaqHistSvc::m_numSlots {this, "NumSlots", 8, "Number of slots for the main monitoring task"}

private

Definition at line 191 of file WebdaqHistSvc.h.

191{this, "NumSlots", 8, "Number of slots for the main monitoring task"};

◆ m_numSlotsFast

Gaudi::Property<int> WebdaqHistSvc::m_numSlotsFast {this, "NumSlotsFast", 1, "Number of slots for the fast monitoring task"}

private

Definition at line 192 of file WebdaqHistSvc.h.

192{this, "NumSlotsFast", 1, "Number of slots for the fast monitoring task"};

◆ m_OHServerName

Gaudi::Property<std::string> WebdaqHistSvc::m_OHServerName {this, "OHServerName", "Histogramming", "Name of the OH server to publish histograms into"}

private

Definition at line 195 of file WebdaqHistSvc.h.

195{this, "OHServerName", "Histogramming", "Name of the OH server to publish histograms into"};

◆ m_outputfile

Gaudi::Property<std::vector<std::string> > WebdaqHistSvc::m_outputfile {this, "Output", {}, "Not supported by WebdaqHistSvc"}

private

Definition at line 204 of file WebdaqHistSvc.h.

204{this, "Output", {}, "Not supported by WebdaqHistSvc"};

◆ m_partition

std::string WebdaqHistSvc::m_partition

private

The partition to publish to.

Definition at line 155 of file WebdaqHistSvc.h.

◆ m_print

Gaudi::Property<bool> WebdaqHistSvc::m_print {this, "PrintAll", false, "Not supported by WebdaqHistSvc"}

private

Definition at line 202 of file WebdaqHistSvc.h.

202{this, "PrintAll", false, "Not supported by WebdaqHistSvc"};

◆ m_PublicationIncludeName

Gaudi::Property<std::string> WebdaqHistSvc::m_PublicationIncludeName {this, "PublicationIncludeName",".*","Regex to select histograms for publication"}

private

Definition at line 196 of file WebdaqHistSvc.h.

196{this, "PublicationIncludeName",".*","Regex to select histograms for publication"};

◆ m_PublicationIncludeNameRegex

boost::regex WebdaqHistSvc::m_PublicationIncludeNameRegex

private

Definition at line 212 of file WebdaqHistSvc.h.

◆ m_stopFlag

std::atomic<bool> WebdaqHistSvc::m_stopFlag {false}

private

Flag to stop the monitoring task.

Definition at line 144 of file WebdaqHistSvc.h.

144{false};

◆ m_tdaqOHServerName

std::string WebdaqHistSvc::m_tdaqOHServerName

private

The OH server name (TDAQ_OH_SERVER if defined, m_OHServerName otherwise).

Definition at line 159 of file WebdaqHistSvc.h.

◆ m_tdaqWebdaqBase

std::string WebdaqHistSvc::m_tdaqWebdaqBase

private

Webdaq configuration variable, see https://gitlab.cern.ch/atlas-tdaq-software/webdaq.

Definition at line 157 of file WebdaqHistSvc.h.

◆ m_thread

std::thread WebdaqHistSvc::m_thread

private

Publication thread.

Definition at line 152 of file WebdaqHistSvc.h.

◆ m_threadFast

std::thread WebdaqHistSvc::m_threadFast

private

Definition at line 153 of file WebdaqHistSvc.h.

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ WebdaqHistSvc()

◆ ~WebdaqHistSvc()

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE()

◆ conditionedSleep()

◆ deReg() [1/2]

◆ deReg() [2/2]

◆ exists()

◆ existsEfficiency()

◆ existsGraph()

◆ existsHist()

◆ existsTree()

◆ finalize()

◆ getEfficiencies()

◆ getEfficiency()

◆ getGraph()

◆ getGraphs()

◆ getHist() [1/3]

◆ getHist() [2/3]

◆ getHist() [3/3]

◆ getHist_i()

◆ getHists()

◆ getSet()

◆ getShared() [1/5]

◆ getShared() [2/5]

◆ getShared() [3/5]

◆ getShared() [4/5]

◆ getShared() [5/5]

◆ getShared_i()

◆ getTEfficiencies() [1/4]

◆ getTEfficiencies() [2/4]

◆ getTEfficiencies() [3/4]

◆ getTEfficiencies() [4/4]

◆ getTHists() [1/4]

◆ getTHists() [2/4]

◆ getTHists() [3/4]

◆ getTHists() [4/4]

◆ getTHists_i()

◆ getTree()

◆ getTrees()

◆ getTTrees() [1/4]

◆ getTTrees() [2/4]

◆ getTTrees() [3/4]

◆ getTTrees() [4/4]

◆ handle()

◆ isObjectAllowed()

◆ merge() [1/2]

◆ merge() [2/2]

◆ monitoringTask()

◆ regEfficiency() [1/3]

◆ regEfficiency() [2/3]

◆ regEfficiency() [3/3]

◆ regGraph() [1/3]

◆ regGraph() [2/3]

◆ regGraph() [3/3]

◆ regHist() [1/3]

◆ regHist() [2/3]

◆ regHist() [3/3]

◆ regHist_i()

◆ regShared() [1/5]

◆ regShared() [2/5]

◆ regShared() [3/5]

◆ regShared() [4/5]

◆ regShared() [5/5]

◆ regShared_i()

◆ regTree() [1/3]

◆ regTree() [2/3]

◆ regTree() [3/3]

◆ stop()

◆ syncPublish()

Member Data Documentation

◆ m_autoFlush

◆ m_autoSave

◆ m_excludeName