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_.size() > 0 && pathLastFilterAccepted_.size() == pathNames_.size() ); };
      bool hasL3Filter() const { return ( pathL3FilterAccepted_.size() > 0 && 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;

      virtual ~TriggerObjectStandAlone() {};


      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 ); };
      virtual bool hasCollection( const std::string & collName ) const;
      virtual bool hasCollection( const edm::InputTag & collName ) const { 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 ) ); };
      virtual bool coll( const std::string & collName ) const { 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;

}


#endif