GenericMonitoringTool Class Reference

#include <GenericMonitoringTool.h>

Inheritance diagram for GenericMonitoringTool:

Collaboration diagram for GenericMonitoringTool:

Classes
class	GenericMonitoringArray
class	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 More...
StatusCode	book ()
	Book histograms. More...
void	setPath (const std::string &newPath)
	Overrride configured booking path. More...
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. More...
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 More...
std::vector< std::shared_ptr< Monitored::HistogramFiller > >	m_alwaysCreateFillers
	fillers that need touching, usually empty More...
fillerCache_t m_fillerCacheMap	ATLAS_THREAD_SAFE {fillerCache_t::Updater_t()}
	lookup map to speed up filler searches More...

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 21 of file GenericMonitoringTool.cxx.

{ }

Member Function Documentation

book()

StatusCode GenericMonitoringTool::book

(

)

Book histograms.

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

{ return m_histoPath; }

handle()

void GenericMonitoringTool::handle ( const Incident &  )

override

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

{ return m_histSvc; }

initialize()

StatusCode GenericMonitoringTool::initialize ( )

overridevirtual

Definition at line 23 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 164 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::vector<std::shared_ptr<Monitored::HistogramFiller>>* matchedFillerList{nullptr};
  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 = new std::vector<std::shared_ptr<Monitored::HistogramFiller>>;
    }
  }
 
  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 246 of file GenericMonitoringTool.cxx.

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

runNumber()

uint32_t GenericMonitoringTool::runNumber ( )

virtual

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

{ m_histoPath = newPath; }

start()

StatusCode GenericMonitoringTool::start ( )

overridevirtual

Definition at line 28 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 36 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.

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.

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.

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.

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.

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.

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.

m_useCache

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

private

Definition at line 81 of file GenericMonitoringTool.h.

---

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

• GenericMonitoringTool.h
• GenericMonitoringTool.py
• GenericMonitoringTool.cxx