EventContainer.h

Go to the documentation of this file.

// -*- C++ -*-
 
#if !defined(EventContainer_H)
#define EventContainer_H
 
#include <map>
#include <string>
#include <typeinfo>
 
#include "TH1.h"
#include "TFile.h"
 
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Common/interface/Handle.h"
#include "PhysicsTools/FWLite/interface/CommandLineParser.h"
#include "DataFormats/FWLite/interface/EventBase.h"
#include "PhysicsTools/FWLite/interface/TH1Store.h"
 
namespace fwlite {
 
  class EventContainer : public EventBase {
  public:
    // Public Constants //
 
    typedef std::map<std::string, std::string> SSMap;
    typedef void (*FuncPtr)(std::string&);
 
    // friends //
    // tells particle data how to print itself out
    friend std::ostream& operator<<(std::ostream& o_stream, const EventContainer& rhs);
 
    //            _         //
    // |\/|      |_         //
    // |  |EMBER | UNCTIONS //
    //                      //
 
    // Constructors and Destructor //
    EventContainer(optutl::CommandLineParser& parser, FuncPtr funcPtr = nullptr);
    ~EventContainer() override;
 
    // One Liners //
 
    // return number of events seen
    int eventsSeen() const { return m_eventsSeen; }
 
    // Regular Member Functions //
 
    // adds a histogram pointer to the map.  You can specify a
    // directory as well if you wish.
    void add(TH1* histPtr, const std::string& directory = "");
 
    // given a string, returns corresponding histogram pointer
    TH1* hist(const std::string& name);
    TH1* hist(const char* name) { return hist((const std::string)name); }
    TH1* hist(const TString& name) { return hist((const char*)name); }
 
    // return this containers parser
    optutl::CommandLineParser& parser();
 
    // Implement the two functions needed to make this an EventBase. //
    bool getByLabel(const std::type_info& iInfo,
                    const char* iModuleLabel,
                    const char* iProductInstanceLabel,
                    const char* iProcessLabel,
                    void* oData) const override;
 
    const std::string getBranchNameFor(const std::type_info& iInfo,
                                       const char* iModuleLabel,
                                       const char* iProductInstanceLabel,
                                       const char* iProcessLabel) const override;
 
    const EventContainer& operator++() override;
 
    const EventContainer& toBegin() override;
 
    bool atEnd() const override;
 
    edm::TriggerNames const& triggerNames(edm::TriggerResults const& triggerResults) const override {
      return m_eventBasePtr->triggerNames(triggerResults);
    }
 
    edm::TriggerResultsByName triggerResultsByName(edm::TriggerResults const& triggerResults) const override {
      return m_eventBasePtr->triggerResultsByName(triggerResults);
    }
 
    Long64_t fileIndex() const override { return m_eventBasePtr->fileIndex(); }
    Long64_t secondaryFileIndex() const override { return m_eventBasePtr->secondaryFileIndex(); }
 
    edm::EventAuxiliary const& eventAuxiliary() const override { return m_eventBasePtr->eventAuxiliary(); }
 
    template <class T>
    bool getByLabel(const edm::InputTag& tag, edm::Handle<T>& handle) const {
      return m_eventBasePtr->getByLabel(tag, handle);
    }
    // Static Member Functions //
 
  private:
    // Private Member Functions //
 
    // stop the copy constructor
    EventContainer(const EventContainer& rhs) {}
 
    // Private Member Data //
 
    fwlite::EventBase* m_eventBasePtr;
    TH1Store m_histStore;
    std::string m_outputName;
    int m_eventsSeen;
    int m_maxWanted;
    int m_outputEvery;
    optutl::CommandLineParser* m_parserPtr;
 
    // Private Static Member Data //
 
    static bool sm_autoloaderCalled;
  };
}  // namespace fwlite
 
#endif  // EventContainer_H