TriggerEvent.h

Go to the documentation of this file.

#ifndef DataFormats_PatCandidates_TriggerEvent_h
#define DataFormats_PatCandidates_TriggerEvent_h


// -*- C++ -*-
//
// Package:    PatCandidates
// Class:      pat::TriggerEvent
//
//
#include "DataFormats/PatCandidates/interface/TriggerAlgorithm.h"
#include "DataFormats/PatCandidates/interface/TriggerCondition.h"
#include "DataFormats/PatCandidates/interface/TriggerPath.h"
#include "DataFormats/PatCandidates/interface/TriggerFilter.h"
#include "DataFormats/PatCandidates/interface/TriggerObject.h"

#include <string>
#include <vector>
#include <boost/cstdint.hpp>

#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/OrphanHandle.h"
#include "DataFormats/Candidate/interface/Candidate.h"


namespace pat {

  class TriggerEvent {


      std::string nameL1Menu_;
      std::string nameHltTable_;
      bool run_;
      bool accept_;
      bool error_;
      bool physDecl_;
      boost::uint32_t lhcFill_;
      boost::uint16_t beamMode_;
      boost::uint16_t beamMomentum_;
      boost::uint32_t intensityBeam1_;
      boost::uint32_t intensityBeam2_;
      boost::uint16_t bstMasterStatus_;
      boost::uint32_t turnCount_;
      float bCurrentStart_;
      float bCurrentStop_;
      float bCurrentAvg_;

      TriggerAlgorithmRefProd algorithms_;
      TriggerConditionRefProd conditions_;
      TriggerPathRefProd paths_;
      TriggerFilterRefProd filters_;
      TriggerObjectRefProd objects_;
      TriggerObjectMatchContainer objectMatchResults_;

    public:


      TriggerEvent();
      TriggerEvent( const std::string & nameHltTable, bool run = true, bool accept = true, bool error = false, bool physDecl = true );
      TriggerEvent( const std::string & nameL1Menu, const std::string & nameHltTable, bool run = true, bool accept = true, bool error = false, bool physDecl = true );

      virtual ~TriggerEvent() {};


      void setNameL1Menu( const std::string & name ) { nameL1Menu_  = name; };
      void setNameHltTable( const std::string & name ) { nameHltTable_ = name; };
      void setRun( bool run ) { run_ = run; };
      void setAccept( bool accept ) { accept_ = accept; };
      void setError( bool error ) { error_ = error; };
      void setPhysDecl( bool physDecl ) { physDecl_ = physDecl; };
      void setLhcFill( boost::uint32_t lhcFill )  { lhcFill_  = lhcFill; };
      void setBeamMode( boost::uint16_t beamMode ) { beamMode_  = beamMode; };
      void setBeamMomentum( boost::uint16_t beamMomentum ) { beamMomentum_ = beamMomentum; };
      void setIntensityBeam1( boost::uint32_t intensityBeam1 ) { intensityBeam1_ = intensityBeam1; };
      void setIntensityBeam2( boost::uint32_t intensityBeam2 ) { intensityBeam2_ = intensityBeam2; };
      void setBstMasterStatus( boost::uint16_t bstMasterStatus ) { bstMasterStatus_ = bstMasterStatus; };
      void setTurnCount( boost::uint32_t turnCount ) { turnCount_ = turnCount; };
      void setBCurrentStart( float bCurrentStart )  { bCurrentStart_ = bCurrentStart; };
      void setBCurrentStop( float bCurrentStop ) { bCurrentStop_ = bCurrentStop; };
      void setBCurrentAvg( float bCurrentAvg ) { bCurrentAvg_  = bCurrentAvg; };
      const std::string & nameL1Menu() const { return nameL1Menu_; };
      const std::string & nameHltTable() const { return nameHltTable_; };
      bool wasRun() const { return run_; };
      bool wasAccept() const { return accept_; };
      bool wasError() const { return error_; };
      bool wasPhysDecl() const { return physDecl_; };
      boost::uint32_t lhcFill() const { return lhcFill_; };
      boost::uint16_t beamMode() const { return beamMode_; };
      boost::uint16_t beamMomentum() const { return beamMomentum_; };
      boost::uint32_t intensityBeam1() const { return intensityBeam1_; };
      boost::uint32_t intensityBeam2() const { return intensityBeam2_; };
      boost::uint16_t bstMasterStatus() const { return bstMasterStatus_; };
      boost::uint32_t turnCount() const { return turnCount_; };
      float bCurrentStart() const { return bCurrentStart_; };
      float bCurrentStop() const { return bCurrentStop_; };
      float bCurrentAvg() const { return bCurrentAvg_; };

      void setAlgorithms( const edm::Handle< TriggerAlgorithmCollection > & handleTriggerAlgorithms ) { algorithms_ = TriggerAlgorithmRefProd( handleTriggerAlgorithms ); };
      const TriggerAlgorithmCollection * algorithms() const { return algorithms_.get(); };
      const TriggerAlgorithmRefVector algorithmRefs() const;
      const TriggerAlgorithm * algorithm( const std::string & nameAlgorithm ) const;
      const TriggerAlgorithmRef algorithmRef( const std::string & nameAlgorithm ) const;
      std::string nameAlgorithm( const unsigned bitAlgorithm, const bool techAlgorithm = true ) const;
      unsigned indexAlgorithm( const std::string & nameAlgorithm ) const;
      TriggerAlgorithmRefVector acceptedAlgorithms() const;
      TriggerAlgorithmRefVector acceptedAlgorithmsGtl() const;
      TriggerAlgorithmRefVector techAlgorithms() const;
      TriggerAlgorithmRefVector acceptedTechAlgorithms() const;
      TriggerAlgorithmRefVector acceptedTechAlgorithmsGtl() const;
      TriggerAlgorithmRefVector physAlgorithms() const;
      TriggerAlgorithmRefVector acceptedPhysAlgorithms() const;
      TriggerAlgorithmRefVector acceptedPhysAlgorithmsGtl() const;

      void setConditions( const edm::Handle< TriggerConditionCollection > & handleTriggerConditions ) { conditions_ = TriggerConditionRefProd( handleTriggerConditions ); };
      const TriggerConditionCollection * conditions() const { return conditions_.get(); };
      const TriggerConditionRefVector conditionRefs() const;
      const TriggerCondition * condition( const std::string & nameCondition ) const;
      const TriggerConditionRef conditionRef( const std::string & nameCondition ) const;
      unsigned indexCondition( const std::string & nameCondition ) const;
      TriggerConditionRefVector acceptedConditions() const;

      void setPaths( const edm::Handle< TriggerPathCollection > & handleTriggerPaths ) { paths_ = TriggerPathRefProd( handleTriggerPaths ); };
      const TriggerPathCollection * paths() const { return paths_.get(); };
      const TriggerPathRefVector pathRefs() const;
      const TriggerPath * path( const std::string & namePath ) const;
      const TriggerPathRef pathRef( const std::string & namePath ) const;
      unsigned indexPath( const std::string & namePath ) const;
      TriggerPathRefVector acceptedPaths() const;

      void setFilters( const edm::Handle< TriggerFilterCollection > & handleTriggerFilters ) { filters_ = TriggerFilterRefProd( handleTriggerFilters ); };
      const TriggerFilterCollection * filters() const { return filters_.get(); };
      const TriggerFilterRefVector filterRefs() const;
      const TriggerFilter * filter( const std::string & labelFilter ) const;
      const TriggerFilterRef filterRef( const std::string & labelFilter ) const;
      unsigned indexFilter( const std::string & labelFilter ) const;
      TriggerFilterRefVector acceptedFilters() const;

      void setObjects( const edm::Handle< TriggerObjectCollection > & handleTriggerObjects ) { objects_ = TriggerObjectRefProd( handleTriggerObjects ); };
      const TriggerObjectCollection * objects() const { return objects_.get(); };
      const TriggerObjectRefVector objectRefs() const;
      TriggerObjectRefVector objects( trigger::TriggerObjectType triggerObjectType ) const;
      TriggerObjectRefVector objects( int                        triggerObjectType ) const { return objects( trigger::TriggerObjectType( triggerObjectType ) ); }; // for backward compatibility

      TriggerConditionRefVector algorithmConditions( const std::string & nameAlgorithm ) const;
      bool conditionInAlgorithm( const TriggerConditionRef & conditionRef, const std::string & nameAlgorithm ) const;
      TriggerAlgorithmRefVector conditionAlgorithms( const TriggerConditionRef & conditionRef ) const;
      std::vector< std::string > conditionCollections( const std::string & nameAlgorithm ) const;
      TriggerObjectRefVector conditionObjects( const std::string & nameCondition ) const;
      bool objectInCondition( const TriggerObjectRef & objectRef, const std::string & nameCondition ) const;
      TriggerConditionRefVector objectConditions( const TriggerObjectRef & objectRef ) const;
      TriggerObjectRefVector algorithmObjects( const std::string & nameAlgorithm ) const;
      bool objectInAlgorithm( const TriggerObjectRef & objectRef, const std::string & nameAlgorithm ) const;
      TriggerAlgorithmRefVector objectAlgorithms( const TriggerObjectRef & objectRef  ) const;

      TriggerFilterRefVector pathModules( const std::string & namePath, bool all = true ) const;
      TriggerFilterRefVector pathFilters( const std::string & namePath, bool firing = true ) const;
      bool filterInPath( const TriggerFilterRef & filterRef, const std::string & namePath, bool firing = true ) const;
      TriggerPathRefVector filterPaths( const TriggerFilterRef & filterRef, bool firing = true ) const;
      std::vector< std::string > filterCollections( const std::string & labelFilter ) const;
      TriggerObjectRefVector filterObjects( const std::string & labelFilter ) const;
      bool objectInFilter( const TriggerObjectRef & objectRef, const std::string & labelFilter ) const;
      TriggerFilterRefVector objectFilters( const TriggerObjectRef & objectRef, bool firing = true ) const;
      TriggerObjectRefVector pathObjects( const std::string & namePath, bool firing = true ) const;
      bool objectInPath( const TriggerObjectRef & objectRef, const std::string & namePath, bool firing = true ) const;
      TriggerPathRefVector objectPaths( const TriggerObjectRef & objectRef, bool firing = true  ) const;

      bool addObjectMatchResult( const TriggerObjectMatchRefProd               & trigMatches, const std::string & labelMatcher );
      bool addObjectMatchResult( const edm::Handle< TriggerObjectMatch >       & trigMatches, const std::string & labelMatcher ) { return addObjectMatchResult( TriggerObjectMatchRefProd( trigMatches ), labelMatcher ); };
      bool addObjectMatchResult( const edm::OrphanHandle< TriggerObjectMatch > & trigMatches, const std::string & labelMatcher ) { return addObjectMatchResult( TriggerObjectMatchRefProd( trigMatches ), labelMatcher ); };
      std::vector< std::string > triggerMatchers() const;
      const TriggerObjectMatchContainer * triggerObjectMatchResults() const { return &objectMatchResults_; };
      const TriggerObjectMatch * triggerObjectMatchResult( const std::string & labelMatcher ) const;


  };

}


#endif