ChainEvent.h

Go to the documentation of this file.

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

// user include files
#include "DataFormats/FWLite/interface/Event.h"
#include "DataFormats/FWLite/interface/EventBase.h"
#include "FWCore/Utilities/interface/propagate_const.h"

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

namespace fwlite {

   class ChainEvent : public EventBase
{

   public:

      ChainEvent(std::vector<std::string> const& iFileNames);
      ~ChainEvent() override;

      ChainEvent const& operator++() override;

      bool to(Long64_t iIndex);

      // If lumi is non-zero, go to event by Run, Lumi and Event number
      // If lumi is 0, go to event by Run and Event number only.
      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);

      // Go to the very first Event.
      ChainEvent const& toBegin() override;

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

      using fwlite::EventBase::getByLabel;

      // This function should only be called by fwlite::Handle<>
      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;

      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;
      std::vector<std::string> const& getProcessHistory() const;
      edm::ProcessHistory const& processHistory() const override;
      TFile* getTFile() const {
        return event_->getTFile();
      }

      // These functions return the index of the file that the current event
      // resides in. Note that the file index is based on the vector of files
      // which were actually opened, not the vector of input files in the
      // constructor. These two may differ in the case some input files contain
      // 0 events. To get the path of the file where the current event resides
      // in, fwlite::ChainEvent::getTFile()->GetPath() is preferred.
      Long64_t eventIndex() const { return eventIndex_; }
      Long64_t fileIndex() const override { return eventIndex_; }

      void setGetter(std::shared_ptr<edm::EDProductGetter const> getter){
         event_->setGetter(getter);
      }

      Event const* event() const { return &*event_; }

      edm::TriggerNames const& triggerNames(edm::TriggerResults const& triggerResults) const override;
      void fillParameterSetRegistry() const ;
      edm::TriggerResultsByName triggerResultsByName(edm::TriggerResults const& triggerResults) const override;

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

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

      // ---------- member functions ---------------------------

      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;

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

   private:

      friend class MultiChainEvent;

      ChainEvent(Event const&); // stop default

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

      void findSizes();
      void switchToFile(Long64_t);
      // ---------- member data --------------------------------
      std::vector<std::string> fileNames_;
      edm::propagate_const<std::shared_ptr<TFile>> file_;
      edm::propagate_const<std::shared_ptr<Event>> event_;
      Long64_t eventIndex_;
      std::vector<Long64_t> accumulatedSize_;
      edm::propagate_const<std::shared_ptr<edm::EDProductGetter>> getter_;

};

}
#endif