CutFlowSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
// Header file for class CutFlowSvc
// Authors:
//  Tadej Novak <tadej@cern.ch>
//  Joao Firmino da Costa <joao.costa@cern.ch> and David Cote <david.cote@cern.ch>
 
#ifndef EVENT_BOOKKEEPER_TOOLS__CUT_FLOW_SVC_H
#define EVENT_BOOKKEEPER_TOOLS__CUT_FLOW_SVC_H
 
// Not dual use at the moment
#ifndef XAOD_STANDALONE
 
// STL includes
#include <mutex>
#include <string>
#include <unordered_map>
 
// FrameWork includes
#include <GaudiKernel/ISvcLocator.h>
#include <GaudiKernel/IIncidentListener.h>
#include <GaudiKernel/ServiceHandle.h>
 
// Athena includes
#include <AthenaBaseComps/AthService.h>
#include <AthenaKernel/ICutFlowSvc.h>
#include <CxxUtils/checker_macros.h>
#include <StoreGate/StoreGateSvc.h>
 
// EDM includes
#include <xAODCutFlow/CutBookkeeper.h>
#include <EventBookkeeperTools/CutBookkeepersLocalCache.h>
 
 
class CutFlowSvc :
  public extends<AthService,
                 ICutFlowSvc,
                 IIncidentListener>
{
 
public:
  CutFlowSvc(const std::string& name, ISvcLocator* pSvcLocator );
 
 
  virtual StatusCode initialize() override final;
 
 
  virtual void handle(const Incident& incident) override final;
 
public:
 
  virtual CutIdentifier registerFilter(const std::string& name,
                                       const std::string& description,
                                       bool nominalOnly) override final;
 
  virtual CutIdentifier registerTopFilter ATLAS_NOT_THREAD_SAFE (const std::string& name,
                                          const std::string& description,
                                          unsigned int logic,
                                          const std::string& outputStream,
                                          bool nominalOnly) override final;
 
  virtual CutIdentifier registerCut(const std::string& name,
                                    const std::string& description,
                                    CutIdentifier parentCutID,
                                    bool nominalOnly) override final;
 
  virtual void setFilterDescription(CutIdentifier cutID,
                                    const std::string& descr) override final;
 
  virtual void addEvent(CutIdentifier cutID,
                        const std::vector<float>& weights) override final;
 
  virtual void addEvent(CutIdentifier cutID,
                        double weight) override final;
 
  virtual uint64_t getNAcceptedEvents(const CutIdentifier cutID) const override final;
 
  const CutBookkeepersLocalCache &getCutBookkeepers() const;
 
  StatusCode setNumberOfWeightVariations(size_t count);
 
 
private:
  void addEvent(CutIdentifier cutID,
                size_t index,
                double weight);
 
  StatusCode determineCycleNumberFromInput(const std::string& collName);
 
  StatusCode createContainers(size_t count);
 
  xAOD::CutBookkeeper* getCutBookkeeper(const CutIdentifier cutID,
                                        size_t index) const;
 
  Gaudi::Property<bool> m_configured{this, "Configured", true, "configuration check"};
 
  ServiceHandle<StoreGateSvc> m_inMetaDataStore{this, "InputMetaDataStore", "StoreGateSvc/InputMetaDataStore", ""};
 
  Gaudi::Property<std::string> m_completeCollName{this, "OutputCollName", "CutBookkeepers", ""};
 
  CutBookkeepersLocalCache m_containers;
 
  Gaudi::Property<int> m_skimmingCycle{this, "SkimmingCycle", 0, "Skimming cycle of current job"};
 
  Gaudi::Property<std::string> m_inputStream{this, "InputStream", "N/A", "The name of the input file stream"};
 
  mutable std::recursive_mutex m_addEventMutex;
 
  std::unordered_set<CutIdentifier> m_nominalOnlyCuts;
};
 
#endif // dual use
 
#endif // EVENT_BOOKKEEPER_TOOLS__CUT_FLOW_SVC_H