Event.h

Go to the documentation of this file.

#ifndef DataFormats_FWLite_Event_h
#define DataFormats_FWLite_Event_h
// -*- C++ -*-
//
// Package:     FWLite
// Class  :     Event
//
//
// Original Author:  Chris Jones
//         Created:  Tue May  8 15:01:20 EDT 2007
//
// system include files
#include <typeinfo>
#include <map>
#include <vector>
#include <memory>
#include <cstring>
#include <string>
#include <functional>

#include "Rtypes.h"

// user include files
#include "DataFormats/FWLite/interface/EventBase.h"
#include "DataFormats/FWLite/interface/EntryFinder.h"
#include "DataFormats/FWLite/interface/LuminosityBlock.h"
#include "DataFormats/FWLite/interface/Run.h"
#include "DataFormats/FWLite/interface/InternalDataKey.h"
#include "DataFormats/Provenance/interface/ProcessHistoryRegistry.h"
#include "DataFormats/Provenance/interface/EventProcessHistoryID.h"
#include "DataFormats/Provenance/interface/EventAuxiliary.h"
#include "DataFormats/Provenance/interface/EventID.h"

// forward declarations
namespace edm {
   class WrapperBase;
   class ProductRegistry;
   class BranchDescription;
   class EDProductGetter;
   class EventAux;
   class Timestamp;
   class TriggerResults;
   class TriggerNames;
   class TriggerResultsByName;
}
class TCut;

namespace fwlite {
   class BranchMapReader;
   class HistoryGetterBase;
   class DataGetterHelper;
   class RunFactory;
   class Event : public EventBase
   {

      public:
         // NOTE: Does NOT take ownership so iFile must remain around
         // at least as long as Event.
         // useCache and baFunc (branch-access-function) are passed to
         // DataGetterHelper and help with external management of TTreeCache
         // associated with the file. By default useCache is true and internal
         // DataGetterHelper caching is enabled. When user sets useCache to
         // false no cache is created unless user attaches and controls it
         // himself.
         Event(TFile* iFile, bool useCache=true,
               std::function<void (TBranch const&)> baFunc=[](TBranch const&){});
         ~Event() override;

         Event const& operator++() override;

         Long64_t indexFromEventId(edm::RunNumber_t run, edm::LuminosityBlockNumber_t lumi, edm::EventNumber_t event);

         bool to (Long64_t iIndex);

         bool to(const edm::EventID &id);
         bool to(edm::RunNumber_t run, edm::EventNumber_t event);
         bool to(edm::RunNumber_t run, edm::LuminosityBlockNumber_t lumi, edm::EventNumber_t event);

         Event const& toBegin() override;

         // ---------- const member functions ---------------------
         std::string const getBranchNameFor(std::type_info const&,
                                                    char const* iModuleLabel,
                                                    char const* iProductInstanceLabel,
                                                    char const* iProcessName) const override;

         using fwlite::EventBase::getByLabel;
         bool getByLabel(std::type_info const&, char const*, char const*, char const*, void*) const override;
         //void getByBranchName(std::type_info const&, char const*, void*&) const;

         void       draw(Option_t* opt);
         Long64_t   draw(char const* varexp, const TCut& selection, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);
         Long64_t   draw(char const* varexp, char const* selection, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);
         Long64_t   scan(char const* varexp = "", char const* selection = "", Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0);

         bool isValid() const;
         operator bool () const;
         bool atEnd() const override;

         Long64_t size() const;

         edm::EventAuxiliary const& eventAuxiliary() const override;

         std::vector<edm::BranchDescription> const& getBranchDescriptions() const {
            return branchMap_.getBranchDescriptions();
         }
         std::vector<std::string> const& getProcessHistory() const;
         TFile* getTFile() const {
            return branchMap_.getFile();
         }

         edm::ParameterSet const* parameterSet(edm::ParameterSetID const& psID) const override;

         edm::WrapperBase const* getByProductID(edm::ProductID const&) const override;
         edm::WrapperBase const* getThinnedProduct(edm::ProductID const& pid, unsigned int& key) const;
         void getThinnedProducts(edm::ProductID const& pid,
                                 std::vector<edm::WrapperBase const*>& foundContainers,
                                 std::vector<unsigned int>& keys) const;

         edm::TriggerNames const& triggerNames(edm::TriggerResults const& triggerResults) const override;

         edm::TriggerResultsByName triggerResultsByName(edm::TriggerResults const& triggerResults) const override;

         edm::ProcessHistory const& processHistory() const override {return history();}

         fwlite::LuminosityBlock const& getLuminosityBlock() const;
         fwlite::Run             const& getRun() const;

         // ---------- static member functions --------------------
         static void throwProductNotFoundException(std::type_info const&, char const*, char const*, char const*);


      private:
         friend class internal::ProductGetter;
         friend class ChainEvent;
         friend class EventHistoryGetter;

         Event(Event const&) = delete; // stop default

         Event const& operator=(Event const&) = delete; // stop default

         edm::ProcessHistory const& history() const;
         void updateAux(Long_t eventIndex) const;
         void fillParameterSetRegistry() const;
         void setGetter(std::shared_ptr<edm::EDProductGetter const> getter) { return dataHelper_.setGetter(getter);}

         // ---------- member data --------------------------------
         mutable TFile* file_;
         // TTree* eventTree_;
         TTree* eventHistoryTree_;
         // Long64_t eventIndex_;
         mutable std::shared_ptr<fwlite::LuminosityBlock>  lumi_;
         mutable std::shared_ptr<fwlite::Run>  run_;
         mutable fwlite::BranchMapReader branchMap_;

         //takes ownership of the strings used by the DataKey keys in data_
         mutable std::vector<char const*> labels_;
         mutable edm::ProcessHistoryMap historyMap_;
         mutable std::vector<edm::EventProcessHistoryID> eventProcessHistoryIDs_;
         mutable std::vector<std::string> procHistoryNames_;
         mutable edm::EventAuxiliary aux_;
         mutable EntryFinder entryFinder_;
         edm::EventAuxiliary const* pAux_;
         edm::EventAux const* pOldAux_;
         TBranch* auxBranch_;
         int fileVersion_;
         mutable bool parameterSetRegistryFilled_;

         fwlite::DataGetterHelper dataHelper_;
         mutable std::shared_ptr<RunFactory> runFactory_;
   };

}
#endif