Worker.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EVENT_LOOP_WORKER_HH
#define EVENT_LOOP_WORKER_HH
 
#include <EventLoop/Global.h>
 
#include <AsgTools/AsgComponentConfig.h>
#include <EventLoop/IInputModuleActions.h>
#include <EventLoop/IWorker.h>
#include <map>
#include <memory>
#include <EventLoop/ModuleData.h>
#include <EventLoop/OutputStreamData.h>
#include <Rtypes.h>
#include <unordered_map>
 
class TList;
class TStopwatch;
 
namespace EL
{
  class Worker final : public IWorker, private Detail::ModuleData, private Detail::IInputModuleActions
  {
    //
    // public interface
    //
 
  public:
    void testInvariant () const;
 
 
  public:
    virtual ~Worker ();
 
 
  public:
    void addOutput (TObject *output_swallow) final override;
 
 
  public:
    void addOutputList (const std::string& name, TObject *output_swallow) override;
 
 
  public:
    TObject *getOutputHist (const std::string& name) const final override;
 
 
  public:
    TFile *getOutputFile (const std::string& label) const override;
 
 
  public:
    TFile *getOutputFileNull (const std::string& label) const override;
 
 
  public:
    ::StatusCode addTree( const TTree& tree,
                          const std::string& stream ) final override;
 
 
  public:
    TTree* getOutputTree( const std::string& name,
                          const std::string& stream ) const final override;
 
 
  public:
    const SH::MetaObject *metaData () const override;
 
 
  public:
    TTree *tree () const override;
 
 
  public:
    Long64_t treeEntry () const override;
 
 
  public:
    TFile *inputFile () const override;
 
 
  public:
    std::string inputFileName () const override;
 
 
  public:
    TTree *triggerConfig () const override;
 
 
  public:
    xAOD::TEvent *xaodEvent () const override;
    xAOD::TStore *xaodStore () const override;
 
 
  public:
    EL::Algorithm *getAlg (const std::string& name) const override;
 
 
  public:
    void skipEvent () override;
 
 
  public:
    virtual bool filterPassed () const noexcept final override;
 
  public:
    virtual void setFilterPassed (bool val_filterPassed) noexcept final override;
 
 
 
    //
    // public interface for the drivers
    //
 
  public:
    Worker ();
 
 
 
    //
    // old interface for the drivers
    //
 
  public:
    ::StatusCode directExecute (const SH::SamplePtr& sample, const Job& job,
                               const std::string& location, const SH::MetaObject& options);
 
 
  public:
    ::StatusCode batchExecute (unsigned job_id, const char *confFile);
 
  public:
    ::StatusCode gridExecute (const std::string& sampleName, Long64_t SkipEvents, Long64_t nEventsPerJob);
 
  private:    
    enum GridErrorCodes {
      EC_FAIL = 220,
      EC_ABORT = 221,
      EC_NOTFINISHED = 222,
      EC_BADINPUT = 223
    };
 
  private:
    void gridCreateJobSummary(uint64_t eventsProcessed);
 
 
  protected:
    void setMetaData (const SH::MetaObject *val_metaData);
 
 
  protected:
    void setOutputHist (const std::string& val_outputTarget);
 
 
  protected:
    void setSegmentName (const std::string& val_segmentName);
 
 
  protected:
    void setJobConfig (JobConfig&& jobConfig);
 
 
  protected:
    ::StatusCode initialize ();
 
 
  protected:
    ::StatusCode processInputs ();
 
 
  protected:
    ::StatusCode finalize ();
 
 
  protected:
    ::StatusCode processEvents (EventRange& eventRange) override;
 
 
  protected:
    ::StatusCode openInputFile (const std::string& inputFileUrl) override;
 
 
  protected:
    ::StatusCode addOutputStream (const std::string& label,
                                  Detail::OutputStreamData output);
 
 
  protected:
    Long64_t inputFileNumEntries () const override;
 
 
  protected:
    uint64_t eventsProcessed () const noexcept;
 
 
 
    //
    // private interface
    //
 
  private:
    static bool fileOpenErrorFilter(int level, bool, const char*, const char *);
 
 
  private:
    typedef std::map<std::string,TH1*>::const_iterator OutputHistMapIter;
    std::map<std::string,TH1*> m_outputHistMap;
 
 
  private:
    typedef std::map<std::pair<std::string,std::string>,TTree*>::const_iterator
       OutputTreeMapIter;
    std::map<std::pair<std::string,std::string>,TTree*> m_outputTreeMap;
 
 
  private:
    std::vector<std::unique_ptr<Detail::Module> > m_modules;
 
 
  private:
    bool m_newInputFile {false};
 
 
  private:
    std::string m_outputTarget;
 
 
  private:
    std::string m_segmentName;
 
 
  private:
    bool m_algorithmsInitialized {false};
 
 
  private:
    bool m_firstEvent {true};
 
 
  private:
    std::vector<asg::AsgComponentConfig> m_moduleConfig;
  };
}
 
#endif