TriggerSelector.h

Go to the documentation of this file.

#ifndef DQMServices_StreamerIO_TriggerSelector_h
#define DQMServices_StreamerIO_TriggerSelector_h

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/Common/interface/HLTPathStatus.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/Provenance/interface/ParameterSetID.h"
#include "FWCore/Framework/interface/EventSelector.h"

#include "boost/shared_ptr.hpp"

#include <vector>
#include <string>

namespace dqmservices {
class TriggerSelector {
 public:
  typedef std::vector<std::string> Strings;

  TriggerSelector(Strings const& pathspecs, Strings const& names);

  TriggerSelector(edm::ParameterSet const& pset, Strings const& triggernames,
                  bool old_ = false);

  TriggerSelector(std::string const& expression, Strings const& triggernames);

  ~TriggerSelector(){};

  bool wantAll() const {
    //  if (useOld_) return eventSelector_->wantAll();
    return acceptAll_;
  }

  bool acceptEvent(edm::TriggerResults const&) const;

  /*
   * Takes array of trigger results and a number of triggers in array and
   * returns
   * if it passes selection
   */
  bool acceptEvent(unsigned char const*, int) const;

  /*
   * Returns if HLTGlobalStatus passes selection
   */
  bool returnStatus(edm::HLTGlobalStatus const& trStatus) const {
    return masterElement_->returnStatus(trStatus);
  }

  /*
   * Does XMl compatible formatting of the selection string
   */
  static std::string makeXMLString(std::string const& input);

  /*
   * Obsolete: Returns SelectedEvents vector from ParameterSet
   */
  static std::vector<std::string> getEventSelectionVString(
      edm::ParameterSet const& pset);

 private:
  bool acceptAll_;

  /*
   * Starts parsing selection string
   */
  void init(std::string const& path, Strings const& triggernames);

  /*
   * Removes extra spaces from string
   */
  static std::string trim(std::string input);

  /*
   * Class used for storing internal representation of the selection string
   */
  class TreeElement {
    enum TreeOperator { NonInit = 0, AND = 1, OR = 2, NOT = 3, BR = 4 };

   public:
    /*
     * Parser of selection string. Splits string into tokens and initializes new
     * elements to parse them.
     */
    TreeElement(std::string const& inputString, Strings const& tr,
                TreeElement* parentElement = NULL);
    ~TreeElement();

    /*
     * Returns selection status of current element calculated recursively from
     * it's child elements
     */
    bool returnStatus(edm::HLTGlobalStatus const& trStatus) const;

    /*
     * Returns operator type of the element
     */
    TreeOperator op() const { return op_; }

    /*
     * Returns parent element
     */
    TreeElement* parent() const { return parent_; }

   private:
    TreeElement* parent_;
    std::vector<TreeElement*> children_;
    TreeOperator op_;
    int trigBit_;
  };

  boost::shared_ptr<TreeElement> masterElement_;

  // keep a copy of initialization string
  std::string expression_;

  boost::shared_ptr<edm::EventSelector> eventSelector_;
  bool useOld_;

  static const bool debug_ = false;
};
}

#endif