FilterReporterParams Class Reference

a handle for applying algorithm filter decisions More...

#include <FilterReporterParams.h>

Inheritance diagram for FilterReporterParams:

Collaboration diagram for FilterReporterParams:

Public Member Functions
template<typename T>
	FilterReporterParams (T *owner, std::string val_filterKey, std::string val_filterDescription)
	standard constructor
StatusCode	initialize (bool enabled=true)
	do anything we need to do in initialize
std::string	summary ()
	report the status of filtering
const std::string &	key () const
	retrieve the key name
const std::string &	description () const
	retrieve the key description
const SG::ReadHandleKey< xAOD::EventInfo > &	eventInfoKey () const
	retrieve the event info read handle key
ServiceHandle< ICutFlowSvc > &	cutFlowSvc ()
	retrieve the CutFlowSvc handle reference
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Private Attributes
std::function< void(bool, const EventContext *ctx)>	m_setFilterPassed
	the function to call setFilterPassed() on the algorithm
bool	m_isInitialized {false}
	whether the handle was initialized
bool	m_isEnabled {false}
	whether the handle was initialized
std::atomic< unsigned >	m_passed {0}
	the count of passed and total events
std::atomic< unsigned >	m_total {0}
std::string	m_filterKey
	output key of the filter
std::string	m_filterDescription
	description what this filter does
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey
	event info read handle key
CutIdentifier	m_cutID {}
	the CutIdentifier for this filter algorithm
ServiceHandle< ICutFlowSvc >	m_cutFlowSvc
	the handle to the service holding tables of cut-flows for filtering algs.
std::function< MsgStream &()>	m_msg
	the message stream we use

Friends
class	FilterReporter

Detailed Description

a handle for applying algorithm filter decisions

This is meant to replace the old/traditional mechanism for recording filter decisions by algorithms, i.e. calling setFilterPassed() on the algorithm base class. This allows to selectively add filter capabilties to algorithms without having to derive from a dedicated algorithm class like AthFilterAlgorithm.

One of the particular reasons to handle filter decisions through a handle is that it makes it fairly easy to add instrumentation (e.g. reporting to the cut flow service), without having to make changes to the base class or indeed without having any extra code in the base class at all. Also it makes sure that only the actual filter algorithms expose properties related to reporting filter decisions (though that would also be true when using a base class).

This should in principle work with any algorithm (or we should be able to make it work with any algorithm). While there isn't any intrinsic reason one couldn't have more than one filter handle per algorithm, that is currently (02 Mar 20) not supported, but could be added on request.

Currently (02 Mar 20) none of the member functions is marked const, which is deliberate to prevent them being called from a reentrant algorithm. I suspect if we ever want to use this in AthenaMT, we will add a second set of member functions that is marked const and will take an event context as an argument.

Definition at line 57 of file FilterReporterParams.h.

Constructor & Destructor Documentation

FilterReporterParams()

template<typename T>

FilterReporterParams::FilterReporterParams ( T * owner, std::string val_filterKey, std::string val_filterDescription )

explicit

standard constructor

Guarantee

strong

Failures

out of memory I

Definition at line 176 of file FilterReporterParams.h.

  : AsgMessagingForward (owner)
  , m_setFilterPassed ([owner] (bool val_setFilterPassed, const EventContext *ctx)
    {
#ifndef XAOD_STANDALONE
      owner->execState (*ctx).setFilterPassed (val_setFilterPassed);
#else
      (void)ctx;
      owner->setFilterPassed (val_setFilterPassed);
#endif
    })
  , m_filterKey (std::move (val_filterKey))
  , m_filterDescription (std::move (val_filterDescription))
  , m_eventInfoKey (owner, "EventInfoKey", "EventInfo", "event info used for cutflow")
#ifndef XAOD_STANDALONE
  , m_cutFlowSvc ("CutFlowSvc/CutFlowSvc", owner->name())
#endif
{
  owner->declareProperty("FilterKey", m_filterKey,
                         "output filter key");
  owner->declareProperty("FilterDescription", m_filterDescription,
                         "describe to the CutFlowSvc what this filter does");
 
#ifndef XAOD_STANDALONE
  owner->declareProperty("CutFlowSvc", m_cutFlowSvc,
                         "handle to the ICutFlowSvc instance this filtering algorithm"
                         " will use for building the flow of cuts.");
#endif
}

Member Function Documentation

cutFlowSvc()

ServiceHandle< ICutFlowSvc > & FilterReporterParams::cutFlowSvc ( )

inline

retrieve the CutFlowSvc handle reference

Definition at line 219 of file FilterReporterParams.h.

{
  return m_cutFlowSvc;
}

description()

const std::string & FilterReporterParams::description ( ) const

inline

retrieve the key description

Definition at line 97 of file FilterReporterParams.h.

{ return m_filterDescription; }

eventInfoKey()

const SG::ReadHandleKey< xAOD::EventInfo > & FilterReporterParams::eventInfoKey ( ) const

inline

retrieve the event info read handle key

Definition at line 211 of file FilterReporterParams.h.

{
  return m_eventInfoKey;
}

initialize()

StatusCode FilterReporterParams::initialize

(

bool

enabled = true

)

do anything we need to do in initialize

Guarantee

strong

Failures

configuration/initialization errors

Author

Nils Krumnack

Tadej Novak

Definition at line 23 of file FilterReporterParams.cxx.

{
  if (m_isInitialized)
  {
    return StatusCode::SUCCESS;
  }
 
  m_isEnabled = enabled;
 
  ANA_CHECK (m_eventInfoKey.initialize(m_isEnabled));
 
#ifndef XAOD_STANDALONE
  if (m_isEnabled && !m_cutFlowSvc.empty())
  {
    ANA_CHECK (m_cutFlowSvc.retrieve());
 
    m_cutID = m_cutFlowSvc->registerFilter (m_filterKey, m_filterDescription, false);
    if (m_cutID == 0)
    {
      ANA_MSG_ERROR ("problem registering myself with the CutFlowSvc");
      return StatusCode::FAILURE;
    }
  }
#endif
 
  // currently not doing anything here, but presumably if we want to
  // add instrumentation, we may/will need to do some initialization
  // work here.
 
  m_isInitialized = true;
  return StatusCode::SUCCESS;
}

key()

const std::string & FilterReporterParams::key ( ) const

inline

retrieve the key name

Definition at line 92 of file FilterReporterParams.h.

{ return m_filterKey; }

msg() [1/2]

MsgStream & asg::AsgMessagingForward::msg ( ) const

inherited

The standard message stream.

Returns

A reference to the default message stream of this object.

Definition at line 24 of file AsgMessagingForward.cxx.

  {
    return m_msg();
  }

msg() [2/2]

MsgStream & asg::AsgMessagingForward::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns

A reference to the default message stream, set to level "lvl"

Definition at line 29 of file AsgMessagingForward.cxx.

  {
    MsgStream& msg = m_msg ();
    msg << lvl;
    return msg;
  }

msgLvl()

bool asg::AsgMessagingForward::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

true If messages at level "lvl" will be printed

Definition at line 11 of file AsgMessagingForward.cxx.

  {
    MsgStream& msg = m_msg();
    if (msg.level() <= lvl)
    {
      msg << lvl;
      return true;
    } else
    {
      return false;
    }
  }

summary()

std::string FilterReporterParams::summary

(

)

report the status of filtering

Returns

a summary string

Definition at line 59 of file FilterReporterParams.cxx.

{
  if (!m_isInitialized)
  {
    return std::string();
  }
 
  std::stringstream stream;
  stream << "accepted " << m_passed << " out of " << m_total << " events for filter "
         << m_filterKey << " (" << m_filterDescription << ")";
 
  return stream.str();
}

Friends And Related Symbol Documentation

FilterReporter

friend class FilterReporter

friend

Definition at line 120 of file FilterReporterParams.h.

Member Data Documentation

m_cutFlowSvc

ServiceHandle<ICutFlowSvc> FilterReporterParams::m_cutFlowSvc

private

the handle to the service holding tables of cut-flows for filtering algs.

Definition at line 165 of file FilterReporterParams.h.

m_cutID

CutIdentifier FilterReporterParams::m_cutID {}

private

the CutIdentifier for this filter algorithm

Definition at line 160 of file FilterReporterParams.h.

{};

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> FilterReporterParams::m_eventInfoKey

private

event info read handle key

Definition at line 154 of file FilterReporterParams.h.

m_filterDescription

std::string FilterReporterParams::m_filterDescription

private

description what this filter does

Definition at line 150 of file FilterReporterParams.h.

m_filterKey

std::string FilterReporterParams::m_filterKey

private

output key of the filter

Definition at line 146 of file FilterReporterParams.h.

m_isEnabled

bool FilterReporterParams::m_isEnabled {false}

private

whether the handle was initialized

Definition at line 135 of file FilterReporterParams.h.

{false};

m_isInitialized

bool FilterReporterParams::m_isInitialized {false}

private

whether the handle was initialized

Definition at line 131 of file FilterReporterParams.h.

{false};

m_msg

std::function<MsgStream& ()> asg::AsgMessagingForward::m_msg

privateinherited

the message stream we use

This used to be a simple pointer to the MsgStream itself, but in AthenaMT the actual object used is local to the thread. So instead of pointing to it directly we are now using a function to look it up, which will get the thread-local object.

Definition at line 77 of file AsgMessagingForward.h.

m_passed

std::atomic<unsigned> FilterReporterParams::m_passed {0}

mutableprivate

the count of passed and total events

While we currently don't run in multi-threaded mode, this is atomic in case we ever use it with reentrant algorithms.

Definition at line 142 of file FilterReporterParams.h.

{0}, m_total {0};

m_setFilterPassed

std::function<void(bool, const EventContext *ctx)> FilterReporterParams::m_setFilterPassed

private

the function to call setFilterPassed() on the algorithm

This is using a std::function object, so as to avoid tying this to a particular algorithm class.

Definition at line 127 of file FilterReporterParams.h.

m_total

std::atomic<unsigned> FilterReporterParams::m_total {0}

private

Definition at line 142 of file FilterReporterParams.h.

{0}, m_total {0};

---

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

• FilterReporterParams.h
• FilterReporterParams.cxx