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 = 0);
         ~EventContainer();

         // 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;

         const std::string getBranchNameFor (const std::type_info& iInfo,
                                             const char* iModuleLabel,
                                             const char* iProductInstanceLabel,
                                             const char* iProcessLabel) const;

         const EventContainer& operator++();

         const EventContainer& toBegin();

         bool atEnd() const;
      
         
         edm::TriggerNames const&  triggerNames(edm::TriggerResults const& triggerResults) const
         { return m_eventBasePtr->triggerNames(triggerResults); }

         edm::TriggerResultsByName triggerResultsByName(edm::TriggerResults const& triggerResults) const
         { return m_eventBasePtr->triggerResultsByName(triggerResults); }

         Long64_t fileIndex()          const 
         { return m_eventBasePtr->fileIndex(); }
         Long64_t secondaryFileIndex() const 
         { return m_eventBasePtr->secondaryFileIndex(); }
         
         edm::EventAuxiliary const& eventAuxiliary() const
         { 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;

   };
}


#endif // EventContainer_H