TriggerObjectStandAlone.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_TriggerObjectStandAlone_h
#define DataFormats_PatCandidates_TriggerObjectStandAlone_h

// -*- C++ -*-
//
// Package:    PatCandidates
// Class:      pat::TriggerObjectStandAlone
//
//
#include "DataFormats/PatCandidates/interface/TriggerObject.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "FWCore/Common/interface/EventBase.h"
namespace edm {
  class TriggerNames;
}

namespace pat {

  class TriggerObjectStandAlone : public TriggerObject {

    std::vector<std::string> filterLabels_;
    std::vector<uint16_t> filterLabelIndices_;

    std::vector<std::string> pathNames_;
    std::vector<uint16_t> pathIndices_;

    std::vector<bool> pathLastFilterAccepted_;
    std::vector<bool> pathL3FilterAccepted_;

    edm::ParameterSetID psetId_;


    static const char wildcard_ = '*';


    bool hasAnyName(const std::string &name, const std::vector<std::string> &nameVec) const;
    void addFilterOrCondition(const std::string &name) {
      if (!hasFilterOrCondition(name))
        filterLabels_.push_back(name);
    };
    void addPathOrAlgorithm(const std::string &name, bool pathLastFilterAccepted, bool pathL3FilterAccepted);
    const std::vector<std::string> &filtersOrConditions() const {
      checkIfFiltersAreUnpacked();
      return filterLabels_;
    };
    std::vector<std::string> pathsOrAlgorithms(bool pathLastFilterAccepted, bool pathL3FilterAccepted) const;
    bool hasFilterOrCondition(const std::string &name) const;
    bool hasPathOrAlgorithm(const std::string &name, bool pathLastFilterAccepted, bool pathL3FilterAccepted) const;
    bool hasLastFilter() const {
      return (!pathLastFilterAccepted_.empty() && pathLastFilterAccepted_.size() == pathNames_.size());
    };
    bool hasL3Filter() const {
      return (!pathL3FilterAccepted_.empty() && pathL3FilterAccepted_.size() == pathNames_.size());
    };

    bool checkIfPathsAreUnpacked(bool throwIfPacked = true) const;
    bool checkIfFiltersAreUnpacked(bool throwIfPacked = true) const;

  public:

    TriggerObjectStandAlone();
    TriggerObjectStandAlone(const TriggerObject &trigObj);
    TriggerObjectStandAlone(const trigger::TriggerObject &trigObj);
    TriggerObjectStandAlone(const reco::LeafCandidate &leafCand);
    TriggerObjectStandAlone(const reco::Particle::LorentzVector &vec, int id = 0);
    TriggerObjectStandAlone(const reco::Particle::PolarLorentzVector &vec, int id = 0);
    TriggerObjectStandAlone(const TriggerObjectStandAlone &) = default;

    ~TriggerObjectStandAlone() override{};


    TriggerObjectStandAlone copy() const { return *this; }

    void addFilterLabel(const std::string &filterLabel) { addFilterOrCondition(filterLabel); };
    void addConditionName(const std::string &conditionName) { addFilterOrCondition(conditionName); };
    void addPathName(const std::string &pathName,
                     bool pathLastFilterAccepted = true,
                     bool pathL3FilterAccepted = true) {
      addPathOrAlgorithm(pathName, pathLastFilterAccepted, pathL3FilterAccepted);
    };
    void addAlgorithmName(const std::string &algorithmName, bool algoCondAccepted = true) {
      addPathOrAlgorithm(algorithmName, algoCondAccepted, false);
    };
    const std::vector<std::string> &filterLabels() const { return filtersOrConditions(); };
    const std::vector<std::string> &conditionNames() const { return filtersOrConditions(); };
    std::vector<std::string> pathNames(bool pathLastFilterAccepted = false, bool pathL3FilterAccepted = true) const {
      return pathsOrAlgorithms(pathLastFilterAccepted, pathL3FilterAccepted);
    };
    std::vector<std::string> algorithmNames(bool algoCondAccepted = true) const {
      return pathsOrAlgorithms(algoCondAccepted, false);
    };
    TriggerObject triggerObject();
    bool hasFilterLabel(const std::string &filterLabel) const { return hasFilterOrCondition(filterLabel); };
    bool hasConditionName(const std::string &conditionName) const { return hasFilterOrCondition(conditionName); };
    bool hasPathName(const std::string &pathName,
                     bool pathLastFilterAccepted = false,
                     bool pathL3FilterAccepted = true) const {
      return hasPathOrAlgorithm(pathName, pathLastFilterAccepted, pathL3FilterAccepted);
    };
    bool hasAlgorithmName(const std::string &algorithmName, bool algoCondAccepted = true) const {
      return hasPathOrAlgorithm(algorithmName, algoCondAccepted, false);
    };
    bool hasCollection(const std::string &collName) const override;
    bool hasCollection(const edm::InputTag &collName) const override { return hasCollection(collName.encode()); };
    bool hasPathLastFilterAccepted() const { return hasLastFilter(); };
    bool hasAlgoCondAccepted() const { return hasLastFilter(); };
    bool hasPathL3FilterAccepted() const { return hasL3Filter(); };


    bool filter(const std::string &filterLabel) const { return hasFilterLabel(filterLabel); };
    bool cond(const std::string &conditionName) const { return hasConditionName(conditionName); };
    bool path(const std::string &pathName,
              unsigned pathLastFilterAccepted = 0,
              unsigned pathL3FilterAccepted = 1) const {
      return hasPathName(pathName, bool(pathLastFilterAccepted), bool(pathL3FilterAccepted));
    };
    bool algo(const std::string &algorithmName, unsigned algoCondAccepted = 1) const {
      return hasAlgorithmName(algorithmName, bool(algoCondAccepted));
    };
    bool coll(const std::string &collName) const override { return hasCollection(collName); };

    void setPSetID(const edm::ParameterSetID &psetId) { psetId_ = psetId; }

    const edm::ParameterSetID &psetID() const { return psetId_; }

    void packFilterLabels(const edm::EventBase &event, const edm::TriggerResults &res);
    void packPathNames(const edm::TriggerNames &names);
    void unpackPathNames(const edm::TriggerNames &names);
    void packFilterLabels(const std::vector<std::string> &labels);
    void unpackFilterLabels(const std::vector<std::string> &labels);
    void unpackFilterLabels(const edm::EventBase &event, const edm::TriggerResults &res);
    void unpackNamesAndLabels(const edm::EventBase &event, const edm::TriggerResults &res);

    void packP4();

    std::vector<std::string> const *allLabels(edm::ParameterSetID const &psetid,
                                              const edm::EventBase &event,
                                              const edm::TriggerResults &res) const;
  };

  typedef std::vector<TriggerObjectStandAlone> TriggerObjectStandAloneCollection;
  typedef edm::Ref<TriggerObjectStandAloneCollection> TriggerObjectStandAloneRef;
  typedef edm::RefProd<TriggerObjectStandAloneCollection> TriggerObjectStandAloneRefProd;
  typedef edm::RefVector<TriggerObjectStandAloneCollection> TriggerObjectStandAloneRefVector;
  typedef edm::RefVectorIterator<TriggerObjectStandAloneCollection> TriggerObjectStandAloneRefVectorIterator;
  typedef edm::Association<TriggerObjectStandAloneCollection> TriggerObjectStandAloneMatch;

}  // namespace pat

#endif