/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/EventLoop/EventLoop/Worker.h

#ifndef EVENT_LOOP_WORKER_HH
#define EVENT_LOOP_WORKER_HH

//          Copyright Nils Krumnack 2011.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

// Please feel free to contact me (krumnack@iastate.edu) for bug
// reports, feature suggestions, praise and complaints.





#include <EventLoop/Global.h>

#include <map>
#include <memory>
#include <vector>
#include <Rtypes.h>
#include <TList.h>
#include <SampleHandler/Global.h>

class TFile;
class TH1;
class TString;
class TTree;
class TStopwatch;

namespace xAOD
{
  class TEvent;
  class TStore;
}

namespace EL
{
  class Worker
  {
    //
    // public interface
    //

  public:
    void testInvariant () const;


  public:
    virtual ~Worker ();


  public:
    void addOutput (TObject *output_swallow);


  public:
    void addOutputList (const std::string& name, TObject *output_swallow);


  public:
    TH1 *getOutputHist (const std::string& name) const;


  public:
    TFile *getOutputFile (const std::string& label) const;


  public:
    TFile *getOutputFileNull (const std::string& label) const;


  public:
    const SH::MetaObject *metaData () const;


  public:
    TTree *tree () const;


  public:
    Long64_t treeEntry () const;


  public:
    TFile *inputFile () const;


  public:
    std::string inputFileName () const;


  public:
    TTree *triggerConfig () const;


  public:
    xAOD::TEvent *xaodEvent () const;
    xAOD::TStore *xaodStore () const;


  public:
    EL::Algorithm *getAlg (const std::string& name) const;


  public:
    void skipEvent ();



    //
    // protected interface
    //

  protected:
    Worker (const SH::MetaObject *val_metaData, TList *output);


  protected:
    void addOutputFile (const std::string& label, TFile *file_swallow);
    void addOutputWriter (const std::string& label,
              SH::DiskWriter *writer_swallow);


  protected:
    void addAlg (EL::Algorithm *alg_swallow);


  protected:
    void algsChangeInput ();


  protected:
    void algsExecute ();


  protected:
    void algsEndOfFile ();


  protected:
    void algsFinalize ();


  protected:
    void treeEntry (Long64_t val_treeEntry);


  protected:
    void setInputFile (TFile *val_inputFile);


  protected:
    void setTreeProofOnly (TTree *val_tree);


  protected:
    Long64_t inputFileNumEntries () const;



    //
    // virtual interface
    //



    //
    // private interface
    //

  private:
    const SH::MetaObject *m_metaData = nullptr;

  private:
    TFile *m_inputFile = nullptr;

  private:
    TTree *m_tree = nullptr;

  private:
    Long64_t m_treeEntry;

  private:
    TList *m_output = nullptr;


  private:
    typedef std::map<std::string,TH1*>::const_iterator OutputHistMapIter;
    std::map<std::string,TH1*> m_outputHistMap;


  private:
    typedef std::map<std::string,SH::DiskWriter*>::const_iterator outputFilesIter;
    std::map<std::string,SH::DiskWriter*> m_outputFiles;


  private:
    typedef std::vector<EL::Algorithm*>::const_iterator algsIter;
    std::vector<EL::Algorithm*> m_algs;


  private:
    TH1 *m_eventCount = nullptr;


  private:
    TH1 *m_runTime = nullptr;


  private:
    TTree *m_fileExecutedTree = nullptr;

  private:
    TString *m_fileExecutedName = nullptr;


  private:
    bool m_skipEvent;


  private:
    std::unique_ptr<TStopwatch> m_stopwatch;


  private:
    enum AlgInitState
    {
      AIS_NEW,

      AIS_HIST_INITIALIZED,

      AIS_INITIALIZED,

      AIS_FINALIZED,

      AIS_HIST_FINALIZED,

      AIS_NONE
    };

  private:
    AlgInitState m_initState;


  private:
    enum AlgExecState
    {
      AES_BLANK,

      AES_FILE_EXECUTED,

      AES_INPUT_CHANGED,

      AES_NONE
    };

  private:
    AlgExecState m_execState;


  private:
    enum InputState
    {
      VALID_NONE,

      VALID_FILE,

      VALID_EVENT
    };


  private:
    void changeAlgState (AlgInitState targetInit, AlgExecState targetExec,
             InputState inputState);
  };
}

#endif

---