#include <GenericMonitoringTool.h>

Inheritance diagram for GenericMonitoringTool:

Collaboration diagram for GenericMonitoringTool:

Public Member Functions
virtual	~GenericMonitoringTool () override
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	stop () override
void	handle (const Incident &) override
void	invokeFillers (const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > &monitoredVariables) const
	feed the fillers
StatusCode	book ()
	Book histograms.
void	setPath (const std::string &newPath)
	Overrride configured booking path.
const std::string &	getPath () const
virtual const ServiceHandle< ITHistSvc > &	histogramService () const
virtual uint32_t	runNumber ()
virtual uint32_t	lumiBlock ()

Public Attributes
	log = logging.getLogger(__name__)

Private Types
using	fillerCache_t = CxxUtils::ConcurrentStrToValMap<std::vector<std::shared_ptr<Monitored::HistogramFiller>>, CxxUtils::SimpleUpdater>

Private Attributes
ServiceHandle< ITHistSvc >	m_histSvc { this, "THistSvc", "THistSvc", "Histogramming svc" }
	THistSvc (do NOT fix the service type (only the name) to allow for a different implementation online.
Gaudi::Property< std::string >	m_histoPath { this, "HistPath", {}, "Directory for histograms [name of parent if not set]" }
Gaudi::Property< std::vector< std::string > >	m_histograms { this, "Histograms", {}, "Definitions of histograms", "OrderedSet<std::string>"}
Gaudi::Property< bool >	m_explicitBooking { this, "ExplicitBooking", false, "Do not create histograms automatically in initialize but wait until the method book is called." }
Gaudi::Property< bool >	m_failOnEmpty { this, "FailOnEmpty", true, "Fail in initialize() if no histograms defined" }
BooleanProperty	m_useCache { this, "UseCache", true, "Cache filler lookups" }
BooleanProperty	m_registerHandler { this, "RegisterHandler", true, "Use incident handler to make 'always book' plots (else only check once)" }
std::vector< std::shared_ptr< Monitored::HistogramFiller > >	m_fillers
	plain list of fillers
std::vector< std::shared_ptr< Monitored::HistogramFiller > >	m_alwaysCreateFillers
	fillers that need touching, usually empty
fillerCache_t m_fillerCacheMap	ATLAS_THREAD_SAFE {fillerCache_t::Updater_t()}
	lookup map to speed up filler searches

Detailed Description

Definition at line 51 of file GenericMonitoringTool.h.

Member Typedef Documentation

◆ fillerCache_t

using GenericMonitoringTool::fillerCache_t = CxxUtils::ConcurrentStrToValMap<std::vector<std::shared_ptr<Monitored::HistogramFiller>>, CxxUtils::SimpleUpdater>

private

Definition at line 86 of file GenericMonitoringTool.h.

Constructor & Destructor Documentation

◆ ~GenericMonitoringTool()

GenericMonitoringTool::~GenericMonitoringTool ( )

overridevirtual

Definition at line 22 of file GenericMonitoringTool.cxx.

22{ }

Member Function Documentation

◆ book()

StatusCode GenericMonitoringTool::book ( )

Book histograms.

Definition at line 55 of file GenericMonitoringTool.cxx.

                                       {
 
  // If no histogram path given use parent or our own name
  if (m_histoPath.empty()) {
    auto named = dynamic_cast<const INamedInterface*>(parent());
    m_histoPath = named ? named->name() : name();
  }
 
  // Replace dot (e.g. MyAlg.MyTool) with slash to create sub-directory
  std::replace( m_histoPath.begin(), m_histoPath.end(), '.', '/' );
 
  ATH_MSG_DEBUG("Booking histograms in path: " << m_histoPath.value());
 
  HistogramFillerFactory factory(this, m_histoPath);
 
  for (const std::string& item : m_histograms) {
    if (item.empty()) {
      ATH_MSG_DEBUG( "Skipping empty histogram definition" );
      continue;
    }
    ATH_MSG_DEBUG( "Configuring monitoring for: " << item );
    HistogramDef def = HistogramDef::parse(item);
 
    if (def.ok) {
      std::shared_ptr<HistogramFiller> filler(factory.create(def));
 
      if (filler) {
        if (def.kAlwaysCreate) {
          if (m_registerHandler) {
            m_alwaysCreateFillers.push_back(filler); // prepare list of fillers for handler
          } else {
            filler->touch(); // create now and be done with it
          }
        }
        m_fillers.push_back(std::move(filler));
      } else {
        ATH_MSG_WARNING( "The histogram filler cannot be instantiated for: " << def.name );
      }
    } else {
      ATH_MSG_ERROR( "Unparsable histogram definition: " << item );
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG( "Monitoring for variable " << def.name << " prepared" );
  }
 
  if ( m_fillers.empty() && m_failOnEmpty ) {
    std::string hists;
    for (const auto &h : m_histograms) hists += (h+",");
    ATH_MSG_ERROR("No monitored variables created based on histogram definition: [" << hists <<
                  "] Remove this monitoring tool or check its configuration.");
    return StatusCode::FAILURE;
  }
 
  // are there some histograms that should always be made?
  // then register to be notified on every event
  if (! m_alwaysCreateFillers.empty() && m_registerHandler) {
    ATH_MSG_DEBUG("Registering incident handler");
    SmartIF<IIncidentSvc> incSvc{service("IncidentSvc")};
    ATH_CHECK(incSvc.isValid());
    incSvc->addListener(this, IncidentType::BeginEvent);
  }
 
  return StatusCode::SUCCESS;
}

◆ getPath()

const std::string & GenericMonitoringTool::getPath ( ) const

inline

Definition at line 68 of file GenericMonitoringTool.h.

68{ return m_histoPath; }

◆ handle()

void GenericMonitoringTool::handle ( const Incident & )

override

Definition at line 49 of file GenericMonitoringTool.cxx.

                                                    {
  for (const auto& filler : m_alwaysCreateFillers) {
    filler->touch();
  }
}

◆ histogramService()

virtual const ServiceHandle< ITHistSvc > & GenericMonitoringTool::histogramService ( ) const

inlinevirtual

Definition at line 70 of file GenericMonitoringTool.h.

70{ return m_histSvc; }

◆ initialize()

StatusCode GenericMonitoringTool::initialize ( )

overridevirtual

Definition at line 24 of file GenericMonitoringTool.cxx.

                                             {
  ATH_CHECK(m_histSvc.retrieve());
  return StatusCode::SUCCESS;
}

◆ invokeFillers()

void GenericMonitoringTool::invokeFillers ( const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > & monitoredVariables ) const

feed the fillers

Definition at line 165 of file GenericMonitoringTool.cxx.

                                                                                                                                      {
  // This is the list of fillers to consider in the invocation.
  // If we are using the cache then this may be a proper subset of m_fillers; otherwise will just be m_fillers
  const std::vector<std::shared_ptr<Monitored::HistogramFiller>>* fillerList{&m_fillers};
  // pointer to list of matched fillers, if we need to update the cache (default doesn't create the vector)
  std::optional<std::vector<std::shared_ptr<Monitored::HistogramFiller>> > matchedFillerList;
  if (m_useCache) {
    const auto match = m_fillerCacheMap.find(fillerKey(monitoredVariables));
    if (match != m_fillerCacheMap.end()) {
      fillerList = &match->second;
    } else {
      // make new cache entry
      matchedFillerList.emplace();
    }
  }
 
  for ( auto filler: *fillerList ) {
    const int fillerCardinality = filler->histogramVariablesNames().size() + (filler->histogramWeightName().empty() ? 0: 1) + (filler->histogramCutMaskName().empty() ? 0 : 1);
 
    if ( fillerCardinality == 1 ) { // simplest case, optimising this to be super fast
      for ( auto& var: monitoredVariables ) {
        if ( var.get().name().compare( filler->histogramVariablesNames()[0] ) == 0 )  {
          {
            auto guard{filler->getLock()};
            filler->fill({&var.get()});
          }
          if (matchedFillerList) {
            matchedFillerList->push_back(std::move(filler));
          }
          break;
        }
      }
    } else { // a more complicated case, and cuts or weights
      int matchesCount = 0;
      Monitored::HistogramFiller::VariablesPack vars;
      for ( const auto& var: monitoredVariables ) {
        bool matched = false;
        for ( unsigned fillerVarIndex = 0; fillerVarIndex < filler->histogramVariablesNames().size(); ++fillerVarIndex ) {
          if ( var.get().name().compare( filler->histogramVariablesNames()[fillerVarIndex] ) == 0 ) {
            vars.set(fillerVarIndex, &var.get());
            matched = true;
            matchesCount++;
            break;
          }
        }
        if ( matchesCount == fillerCardinality ) break;
        if ( not matched ) { // may be a weight or cut variable still
          if ( var.get().name().compare( filler->histogramWeightName() ) == 0 )  {
            vars.weight = &var.get();
            matchesCount ++;
          } else if ( var.get().name().compare( filler->histogramCutMaskName() ) == 0 )  {
            vars.cut = &var.get();
            matchesCount++;
         }
        }
        if ( matchesCount == fillerCardinality ) break;
      }
      if ( matchesCount == fillerCardinality ) {
        {
          auto guard{filler->getLock()};
          filler->fill( vars );
        }
        if (matchedFillerList) {
          matchedFillerList->push_back(std::move(filler));
        }
      } else if ( ATH_UNLIKELY( msgLvl(MSG::DEBUG) && matchesCount != 0 ) ) { // something has matched, but not all, worth informing user
        invokeFillersDebug(msg(), vars, filler, monitoredVariables);
      }
    }
  }
 
  if (matchedFillerList) {
    // We may hit this multiple times. If another thread has updated the cache in the meanwhile,
    // nothing will be done here.
    m_fillerCacheMap.emplace(fillerKey(monitoredVariables), std::move(*matchedFillerList));
  }
}

◆ lumiBlock()

uint32_t GenericMonitoringTool::lumiBlock ( )

virtual

Definition at line 247 of file GenericMonitoringTool.cxx.

                                          {
  return Gaudi::Hive::currentContext().eventID().lumi_block();
}

◆ runNumber()

uint32_t GenericMonitoringTool::runNumber ( )

virtual

Definition at line 243 of file GenericMonitoringTool.cxx.

                                          {
  return Gaudi::Hive::currentContext().eventID().run_number();
}

◆ setPath()

void GenericMonitoringTool::setPath ( const std::string & newPath )

inline

Overrride configured booking path.

Definition at line 67 of file GenericMonitoringTool.h.

67{ m_histoPath = newPath; }

◆ start()

StatusCode GenericMonitoringTool::start ( )

overridevirtual

Definition at line 29 of file GenericMonitoringTool.cxx.

                                        {
  if ( not m_explicitBooking ) {
    ATH_MSG_DEBUG("Proceeding to histogram booking");
    return book();
  }
  return StatusCode::SUCCESS;
}

◆ stop()

StatusCode GenericMonitoringTool::stop ( )

overridevirtual

Definition at line 37 of file GenericMonitoringTool.cxx.

                                       {
  m_alwaysCreateFillers.clear();
  m_fillers.clear();
  if (m_registerHandler) {
    ATH_MSG_DEBUG("Deregistering incident handler");
    SmartIF<IIncidentSvc> incSvc{service("IncidentSvc")};
    ATH_CHECK(incSvc.isValid());
    incSvc->removeListener(this, IncidentType::BeginEvent);
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

◆ ATLAS_THREAD_SAFE

fillerCache_t m_fillerCacheMap GenericMonitoringTool::ATLAS_THREAD_SAFE {fillerCache_t::Updater_t()}

mutableprivate

lookup map to speed up filler searches

Definition at line 87 of file GenericMonitoringTool.h.

87{fillerCache_t::Updater_t()};

◆ log

GenericMonitoringTool.log = logging.getLogger(__name__)

Definition at line 9 of file GenericMonitoringTool.py.

◆ m_alwaysCreateFillers

std::vector<std::shared_ptr<Monitored::HistogramFiller> > GenericMonitoringTool::m_alwaysCreateFillers

private

fillers that need touching, usually empty

Definition at line 85 of file GenericMonitoringTool.h.

◆ m_explicitBooking

Gaudi::Property<bool> GenericMonitoringTool::m_explicitBooking { this, "ExplicitBooking", false, "Do not create histograms automatically in initialize but wait until the method book is called." }

private

Definition at line 79 of file GenericMonitoringTool.h.

79{ this, "ExplicitBooking", false, "Do not create histograms automatically in initialize but wait until the method book is called." };

◆ m_failOnEmpty

Gaudi::Property<bool> GenericMonitoringTool::m_failOnEmpty { this, "FailOnEmpty", true, "Fail in initialize() if no histograms defined" }

private

Definition at line 80 of file GenericMonitoringTool.h.

80{ this, "FailOnEmpty", true, "Fail in initialize() if no histograms defined" };

◆ m_fillers

std::vector<std::shared_ptr<Monitored::HistogramFiller> > GenericMonitoringTool::m_fillers

private

plain list of fillers

Definition at line 84 of file GenericMonitoringTool.h.

◆ m_histograms

Gaudi::Property<std::vector<std::string> > GenericMonitoringTool::m_histograms { this, "Histograms", {}, "Definitions of histograms", "OrderedSet<std::string>"}

private

Definition at line 78 of file GenericMonitoringTool.h.

78{ this, "Histograms", {}, "Definitions of histograms", "OrderedSet<std::string>"};

◆ m_histoPath

Gaudi::Property<std::string> GenericMonitoringTool::m_histoPath { this, "HistPath", {}, "Directory for histograms [name of parent if not set]" }

private

Definition at line 77 of file GenericMonitoringTool.h.

77{ this, "HistPath", {}, "Directory for histograms [name of parent if not set]" };

◆ m_histSvc

ServiceHandle<ITHistSvc> GenericMonitoringTool::m_histSvc { this, "THistSvc", "THistSvc", "Histogramming svc" }

private

THistSvc (do NOT fix the service type (only the name) to allow for a different implementation online.

Definition at line 76 of file GenericMonitoringTool.h.

76{ this, "THistSvc", "THistSvc", "Histogramming svc" };

◆ m_registerHandler

BooleanProperty GenericMonitoringTool::m_registerHandler { this, "RegisterHandler", true, "Use incident handler to make 'always book' plots (else only check once)" }

private

Definition at line 82 of file GenericMonitoringTool.h.

82{ this, "RegisterHandler", true, "Use incident handler to make 'always book' plots (else only check once)" };

◆ m_useCache

BooleanProperty GenericMonitoringTool::m_useCache { this, "UseCache", true, "Cache filler lookups" }

private

Definition at line 81 of file GenericMonitoringTool.h.

81{ this, "UseCache", true, "Cache filler lookups" };

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

Public Member Functions

Public Attributes

Private Types

Private Attributes

Detailed Description

Member Typedef Documentation

◆ fillerCache_t

Constructor & Destructor Documentation

◆ ~GenericMonitoringTool()

Member Function Documentation

◆ book()

◆ getPath()

◆ handle()

◆ histogramService()

◆ initialize()

◆ invokeFillers()

◆ lumiBlock()

◆ runNumber()

◆ setPath()

◆ start()

◆ stop()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ log

◆ m_alwaysCreateFillers

◆ m_explicitBooking

◆ m_failOnEmpty

◆ m_fillers

◆ m_histograms

◆ m_histoPath

◆ m_histSvc

◆ m_registerHandler

◆ m_useCache