TriggerResultsBasedEventSelector.h

Go to the documentation of this file.

#ifndef FWCore_Framework_TriggerResultsBasedEventSelector_h
#define FWCore_Framework_TriggerResultsBasedEventSelector_h
 
// -------------------------------------------------------------------
//
// TriggerResultsBasedEventSelector: This class is used by OutputModule to interact with
// the TriggerResults objects upon which the decision to write out an
// event is made.
//
// -------------------------------------------------------------------
#include <string>
#include <utility>
#include <vector>
#include <map>
 
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "FWCore/Framework/interface/EventPrincipal.h"
#include "FWCore/Framework/interface/EventSelector.h"
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Utilities/interface/EDGetToken.h"
#include "FWCore/Utilities/interface/InputTag.h"
 
namespace edm {
  class EventForOutput;
  class TriggerResults;
 
  namespace detail {
    typedef edm::Handle<edm::TriggerResults> handle_t;
 
    class NamedEventSelector {
    public:
      NamedEventSelector(std::string const& n, EventSelector const& s, ConsumesCollector&& iC)
          : inputTag_("TriggerResults", "", n), token_(iC.consumes<TriggerResults>(inputTag_)), eventSelector_(s) {}
 
      bool match(TriggerResults const& product) { return eventSelector_.acceptEvent(product); }
 
      InputTag const& inputTag() const { return inputTag_; }
 
      EDGetTokenT<TriggerResults> const& token() const { return token_; }
 
    private:
      InputTag inputTag_;
      EDGetTokenT<TriggerResults> token_;
      EventSelector eventSelector_;
    };
 
    class TriggerResultsBasedEventSelector {
    public:
      TriggerResultsBasedEventSelector();
      typedef detail::handle_t handle_t;
      typedef std::vector<NamedEventSelector> selectors_t;
      typedef std::pair<std::string, std::string> parsed_path_spec_t;
 
      void setupDefault();
 
      void setup(std::vector<parsed_path_spec_t> const& path_specs,
                 std::vector<std::string> const& triggernames,
                 std::string const& process_name,
                 ConsumesCollector&& iC);
 
      bool wantEvent(EventForOutput const& e);
 
      unsigned int numberOfTokens() const { return selectors_.size(); }
      EDGetToken token(unsigned int index) const { return selectors_[index].token(); }
 
    private:
      selectors_t selectors_;
      bool wantAllEvents_;
    };
 
    bool configureEventSelector(edm::ParameterSet const& iPSet,
                                std::string const& iProcessName,
                                std::vector<std::string> const& iAllTriggerNames,
                                edm::detail::TriggerResultsBasedEventSelector& oSelector,
                                ConsumesCollector&& iC);
    ParameterSetID registerProperSelectionInfo(
        edm::ParameterSet const& iInitial,
        std::string const& iLabel,
        std::map<std::string, std::vector<std::pair<std::string, int> > > const& outputModulePathPositions,
        bool anyProductProduced);
 
  }  // namespace detail
}  // namespace edm
 
#endif