TriggerPath.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_TriggerPath_h
#define DataFormats_PatCandidates_TriggerPath_h


// -*- C++ -*-
//
// Package:    PatCandidates
// Class:      pat::TriggerPath
//
// $Id: TriggerPath.h,v 1.12 2013/06/11 13:24:49 vadler Exp $
//
#include <string>
#include <vector>

#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/RefProd.h"
#include "DataFormats/Common/interface/RefVector.h"
#include "DataFormats/Common/interface/RefVectorIterator.h"


namespace pat {

  typedef std::pair< bool, std::string > L1Seed;
  typedef std::vector< L1Seed >          L1SeedCollection;

  class TriggerPath {


      std::string name_;
      unsigned index_;
      unsigned prescale_;
      bool run_;
      bool accept_;
      bool error_;
      std::vector< std::string > modules_;
      std::vector< unsigned > filterIndices_;
      unsigned lastActiveFilterSlot_;
      unsigned l3Filters_;
      L1SeedCollection l1Seeds_;

    public:


      TriggerPath();
      TriggerPath( const std::string & name );
      TriggerPath( const std::string & name, unsigned index, unsigned prescale, bool run, bool accept, bool error, unsigned lastActiveFilterSlot, unsigned l3Filters = 0 );

      virtual ~TriggerPath() {};


      void setName( const std::string & name ) { name_ = name; };
      void setIndex( unsigned index ) { index_ = index; };
      void setPrescale( unsigned prescale ) { prescale_ = prescale; };
      void setRun( bool run ) { run_ = run; };
      void setAccept( bool accept ) { accept_ = accept; };
      void setError( bool error ) { error_ = error; };
      void setLastActiveFilterSlot( unsigned lastActiveFilterSlot ) { lastActiveFilterSlot_ = lastActiveFilterSlot; };
      void setL3Filters( unsigned l3Filters ) { l3Filters_ = l3Filters; };
      void addModule( const std::string & name ) { modules_.push_back( name ); };
      void addFilterIndex( const unsigned index ) { filterIndices_.push_back( index ); };
      void addL1Seed( const L1Seed & seed )                           { l1Seeds_.push_back( seed ); };
      void addL1Seed( bool decision, const std::string & expression ) { l1Seeds_.push_back( L1Seed( decision, expression ) ); };
      const std::string & name() const { return name_; };
      unsigned index() const { return index_; };
      unsigned prescale() const { return prescale_; };
      bool wasRun() const { return run_; };
      bool wasAccept() const { return accept_; };
      bool wasError() const { return error_; };
      unsigned lastActiveFilterSlot() const { return lastActiveFilterSlot_; };
      unsigned l3Filters() const { return l3Filters_; };
      bool xTrigger() const { return ( l3Filters_ > 2 ); };
      const std::vector< std::string > & modules() const { return modules_; };
      const std::vector< unsigned > & filterIndices() const { return filterIndices_; };
      int indexModule( const std::string & name ) const;
      const L1SeedCollection & l1Seeds() const { return l1Seeds_; };
      std::vector< std::string > l1Seeds( const bool decision ) const;
      std::vector< std::string > acceptedL1Seeds() const { return l1Seeds( true ); };
      std::vector< std::string > failedL1Seeds() const { return l1Seeds( false ); };

  };


  typedef std::vector< TriggerPath >                      TriggerPathCollection;
  typedef edm::Ref< TriggerPathCollection >               TriggerPathRef;
  typedef edm::RefProd< TriggerPathCollection >           TriggerPathRefProd;
  typedef edm::RefVector< TriggerPathCollection >         TriggerPathRefVector;
  typedef edm::RefVectorIterator< TriggerPathCollection > TriggerPathRefVectorIterator;

}


#endif