AnaAlgorithm.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
 
 
#ifndef ANA_ALGORITHM__ANA_ALGORITHM_H
#define ANA_ALGORITHM__ANA_ALGORITHM_H
 
#include <AnaAlgorithm/Global.h>
 
#ifdef XAOD_STANDALONE
#include <AsgTools/AsgComponent.h>
#include <AsgTools/SgEvent.h>
#include <AsgTools/SgEventMeta.h>
#include <memory>
#include <vector>
#else
#include <AthenaBaseComps/AthHistogramAlgorithm.h>
#include <AsgMessaging/MessageCheck.h>
#include <StoreGate/StoreGateSvc.h>
#include <GaudiKernel/IIncidentListener.h>
#include <GaudiKernel/ServiceHandle.h>
#endif
 
class TH1;
class TH2;
class TH3;
class TEfficiency;
class TTree;
class EventContext;
class ISvcLocator;
 
namespace EL
{
#ifdef XAOD_STANDALONE
  class IWorker;
#endif

 
 
  class AnaAlgorithm
#ifdef XAOD_STANDALONE
    : public asg::AsgComponent
#else
    : public AthHistogramAlgorithm, virtual public IIncidentListener
#endif
  {
    //
    // public interface
    //

  public:
    AnaAlgorithm (const std::string& name, 
                  ISvcLocator* pSvcLocator);

  public:
    virtual ~AnaAlgorithm() noexcept = default;
 
 
 
    //
    // services interface
    //
 
#ifdef XAOD_STANDALONE
    using MetaStorePtr_t = asg::SgEventMeta*;
    using ConstMetaStorePtr_t = const asg::SgEventMeta*;
#else
    using MetaStorePtr_t = ServiceHandle< StoreGateSvc >&;
    using ConstMetaStorePtr_t = const ServiceHandle< StoreGateSvc >&;
#endif // XAOD_STANDALONE

    ConstMetaStorePtr_t inputMetaStore() const;
    MetaStorePtr_t inputMetaStore();

    ConstMetaStorePtr_t outputMetaStore() const;
    MetaStorePtr_t outputMetaStore();
 
#ifdef XAOD_STANDALONE
  public:
    asg::SgEvent *evtStore() const;
 

  public:
    ::StatusCode book (const TH1& hist);
 

  public:
    ::StatusCode book (const TEfficiency& hist);
 

  public:
    template<typename T=TH1>
    T *hist (const std::string& name) const;
 

  public:
    TH2 *hist2d (const std::string& name) const;
 

  public:
    TH3 *hist3d (const std::string& name) const;
 

  public:
    TEfficiency *histeff (const std::string& name) const;
    TEfficiency *efficiency (const std::string& name) const;
 

  public:
    IHistogramWorker *histogramWorker () const;
 

  public:
    ::StatusCode book (const TTree& tree);
 

  public:
    TTree *tree (const std::string& name) const;
 

  public:
    ITreeWorker *treeWorker () const;
 

  public:
    IFilterWorker *filterWorker () const;
 

  public:
    bool filterPassed() const;

  public:
    void setFilterPassed (bool val_filterPassed);
 

  public:
    IWorker *wk () const;
#endif
 

  public:
    ::StatusCode requestFileExecute ();
 

  public:
    ::StatusCode requestBeginInputFile ();
 

  public:
    ::StatusCode requestEndInputFile ();
 
 
 
    //
    // virtual interface
    //

  protected:
    virtual ::StatusCode initialize ();
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Woverloaded-virtual"

  protected:
    virtual ::StatusCode execute ();

  protected:
    virtual ::StatusCode execute (const EventContext& ctx);
 
#pragma GCC diagnostic pop

  protected:
    virtual ::StatusCode finalize ();

  protected:
    virtual void print () const;

  protected:
    virtual ::StatusCode fileExecute ();

  protected:
    virtual ::StatusCode beginInputFile ();

  protected:
    virtual ::StatusCode endInputFile ();
 
 
 
    //
    // framework interface
    //
 
#ifdef XAOD_STANDALONE
  public:
    ::StatusCode sysInitialize ();

  public:
    ::StatusCode sysExecute (const EventContext& ctx);

  public:
    ::StatusCode sysFinalize ();

  public:
    void sysPrint ();

  public:
    ::StatusCode sysFileExecute ();

  public:
    ::StatusCode sysBeginInputFile ();

  public:
    ::StatusCode sysEndInputFile ();
 

  public:
    void setEvtStore (asg::SgEvent *val_evtStore);

  public:
    void setHistogramWorker (IHistogramWorker *val_histogramWorker);

  public:
    void setTreeWorker (ITreeWorker *val_treeWorker);

  public:
    void setFilterWorker (IFilterWorker *val_filterWorker);

  public:
    void setWk (IWorker *val_wk);
 

  public:
    bool hasFileExecute () const noexcept;
 

  public:
    bool hasBeginInputFile () const noexcept;
 

  public:
    bool hasEndInputFile () const noexcept;
#endif
 
 
#ifndef XAOD_STANDALONE
  public:
    void handle (const Incident& inc);
#endif
 
 
 
    //
    // private interface
    //
 
#ifdef XAOD_STANDALONE
  private:
    asg::SgEvent *m_evtStore = nullptr;
#endif
 
#ifdef XAOD_STANDALONE
    using MetaStore_t = asg::SgEventMeta;
#else
    using MetaStore_t = ServiceHandle< StoreGateSvc >;
#endif // XAOD_STANDALONE

  private:
    MetaStore_t m_inputMetaStore;

  private:
    MetaStore_t m_outputMetaStore;
 
#ifdef XAOD_STANDALONE
  private:
    IHistogramWorker *m_histogramWorker = nullptr;
#endif
 
#ifdef XAOD_STANDALONE
  private:
    ITreeWorker *m_treeWorker = nullptr;
  private:
    std::string m_treeStreamName;
#endif
 
#ifdef XAOD_STANDALONE
  private:
    IFilterWorker *m_filterWorker = nullptr;
#endif
 
#ifdef XAOD_STANDALONE
  private:
    IWorker *m_wk = nullptr;
#endif

  private:
    bool m_hasFileExecute {false};

  private:
    bool m_hasBeginInputFile {false};

  private:
    bool m_hasEndInputFile {false};
  };
}
 
#include "AnaAlgorithm.icc"
 
#endif