FilterReporterParams.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
 
 
#ifndef EVENT_BOOKKEEPER_TOOLS__FILTER_REPORTER_PARAMS_H
#define EVENT_BOOKKEEPER_TOOLS__FILTER_REPORTER_PARAMS_H
 
#include <atomic>
#include <functional>
 
#include <AsgDataHandles/ReadHandleKey.h>
#include <AsgMessaging/AsgMessagingForward.h>
#include <xAODEventInfo/EventInfo.h>
 
#ifndef XAOD_STANDALONE
#include <AthenaKernel/ICutFlowSvc.h>
#include <GaudiKernel/ServiceHandle.h>
#endif
 
class EventContext;
class StatusCode;
 
 
class FilterReporterParams final : public asg::AsgMessagingForward
{
  //
  // public interface
  //
 
public:
  template<typename T>
  explicit FilterReporterParams (T *owner,
                                 std::string val_filterKey,
                                 std::string val_filterDescription);
 
 
public:
  StatusCode initialize (bool enabled = true);
 
 
public:
  std::string summary ();
 
  
public:
  const std::string& key() const { return m_filterKey; }
 
 
public:
  const SG::ReadHandleKey<xAOD::EventInfo>& eventInfoKey() const;
 
 
#ifndef XAOD_STANDALONE
 
public:
  ServiceHandle<ICutFlowSvc>& cutFlowSvc();
 
#endif
 
 
  //
  // private interface
  //
 
  // this class does most of the actual work, and needs our
  // internals for that.
  friend class FilterReporter;
 
private:
  std::function<void(bool, const EventContext *ctx)> m_setFilterPassed;
 
private:
  bool m_isInitialized {false};
 
private:
  bool m_isEnabled {false};
 
private:
  mutable std::atomic<unsigned> m_passed {0}, m_total {0};
 
private:
  std::string m_filterKey;
 
private:
  std::string m_filterDescription;
 
private:
  SG::ReadHandleKey<xAOD::EventInfo> m_eventInfoKey;
 
#ifndef XAOD_STANDALONE
 
private:
  CutIdentifier m_cutID{};
 
private:
  ServiceHandle<ICutFlowSvc> m_cutFlowSvc;
 
#endif
};
 
 
 
//
// inline/template methods
//
 
template<typename T> FilterReporterParams ::
FilterReporterParams (T *owner,
                      std::string val_filterKey,
                      std::string val_filterDescription)
  : 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
}
 
 
inline const SG::ReadHandleKey<xAOD::EventInfo> &
FilterReporterParams::eventInfoKey() const
{
  return m_eventInfoKey;
}
 
 
#ifndef XAOD_STANDALONE
inline ServiceHandle<ICutFlowSvc>& 
FilterReporterParams::cutFlowSvc()
{
  return m_cutFlowSvc;
}
#endif
 
#endif