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
//
// $Id: TriggerObjectStandAlone.h,v 1.12 2010/12/20 20:05:52 vadler Exp $
//
#include "DataFormats/PatCandidates/interface/TriggerObject.h"


namespace pat {

  class TriggerObjectStandAlone : public TriggerObject {


      std::vector< std::string > filterLabels_;
      std::vector< std::string > pathNames_;
      std::vector< bool > pathLastFilterAccepted_;


      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 firing = true );
      std::vector< std::string > filtersOrConditions() const { return filterLabels_; };
      std::vector< std::string > pathsOrAlgorithms( bool firing = true ) const;
      bool hasFilterOrCondition( const std::string & name ) const;
      bool hasPathOrAlgorithm( const std::string & name, bool firing = true ) const;
      bool hasFiring() const { return ( pathLastFilterAccepted_.size() > 0 && pathLastFilterAccepted_.size() == pathNames_.size() ); };

    public:


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

      virtual ~TriggerObjectStandAlone() {};


      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 ) { addPathOrAlgorithm( pathName, pathLastFilterAccepted ); };
      void addAlgorithmName( const std::string & algorithmName, bool algoCondAccepted = true ) { addPathOrAlgorithm( algorithmName, algoCondAccepted ); };
      std::vector< std::string > filterLabels() const { return filtersOrConditions(); };
      std::vector< std::string > conditionNames() const { return filtersOrConditions(); };
      std::vector< std::string > pathNames( bool pathLastFilterAccepted = true ) const { return pathsOrAlgorithms( pathLastFilterAccepted ); };
      std::vector< std::string > algorithmNames( bool algoCondAccepted = true ) const { return pathsOrAlgorithms( algoCondAccepted ); };
      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 = true ) const { return hasPathOrAlgorithm( pathName, pathLastFilterAccepted ); };
      bool hasAlgorithmName( const std::string & algorithmName, bool algoCondAccepted = true ) const { return hasPathOrAlgorithm( algorithmName, algoCondAccepted ); };
      virtual bool hasCollection( const std::string & collName ) const;
      virtual bool hasCollection( const edm::InputTag & collName ) const { return hasCollection( collName.encode() ); };
      bool hasPathLastFilterAccepted() const { return hasFiring(); };
      bool hasAlgoCondAccepted() const { return hasFiring(); };


      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 = 1 ) const { return hasPathName( pathName, bool( pathLastFilterAccepted ) ); };
      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 ); };

  };


  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