Analysis-level trigger object class (stand-alone) More...

#include "DataFormats/PatCandidates/interface/TriggerObjectStandAlone.h"

Inheritance diagram for pat::TriggerObjectStandAlone:

Public Member Functions
void	addAlgorithmName (const std::string &algorithmName, bool algoCondAccepted=true)
	Adds a new L1 algorithm name. More...

void	addConditionName (const std::string &conditionName)
	Adds a new L1 condition name. More...

void	addFilterLabel (const std::string &filterLabel)
	Adds a new HLT filter label. More...

void	addPathName (const std::string &pathName, bool pathLastFilterAccepted=true, bool pathL3FilterAccepted=true)
	Adds a new HLT path name. More...

bool	algo (const std::string &algorithmName, unsigned algoCondAccepted=1) const
	Calls 'hasAlgorithmName(...)'. More...

std::vector< std::string >	algorithmNames (bool algoCondAccepted=true) const
	Gets all L1 algorithm names. More...

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

virtual bool	coll (const std::string &collName) const
	Calls 'hasCollection(...)' (method override) More...

bool	cond (const std::string &conditionName) const
	Calls 'hasConditionName(...)'. More...

const std::vector< std::string > &	conditionNames () const
	Gets all L1 condition names. More...

TriggerObjectStandAlone	copy () const
	Methods. More...

bool	filter (const std::string &filterLabel) const
	Calls 'hasFilterLabel(...)'. More...

const std::vector< std::string > &	filterLabels () const
	Gets all HLT filter labels. More...

bool	hasAlgoCondAccepted () const

bool	hasAlgorithmName (const std::string &algorithmName, bool algoCondAccepted=true) const
	Checks, if a certain L1 algorithm name is assigned. More...

virtual bool	hasCollection (const std::string &collName) const
	Checks, if a certain label of original collection is assigned (method overrides) More...

virtual bool	hasCollection (const edm::InputTag &collName) const

bool	hasConditionName (const std::string &conditionName) const
	Checks, if a certain L1 condition name is assigned. More...

bool	hasFilterLabel (const std::string &filterLabel) const
	Checks, if a certain HLT filter label is assigned. More...

bool	hasPathL3FilterAccepted () const

bool	hasPathLastFilterAccepted () const
	Checks, if the usage indicator vector has been filled. More...

bool	hasPathName (const std::string &pathName, bool pathLastFilterAccepted=false, bool pathL3FilterAccepted=true) const
	Checks, if a certain HLT path name is assigned. More...

void	packFilterLabels (const edm::EventBase &event, const edm::TriggerResults &res)

void	packFilterLabels (const std::vector< std::string > &labels)
	pack filter labels into indices; note that the labels must be sorted! More...

void	packP4 ()
	reduce the precision on the 4-vector More...

void	packPathNames (const edm::TriggerNames &names)
	pack trigger names into indices More...

bool	path (const std::string &pathName, unsigned pathLastFilterAccepted=0, unsigned pathL3FilterAccepted=1) const
	Calls 'hasPathName(...)'. More...

std::vector< std::string >	pathNames (bool pathLastFilterAccepted=false, bool pathL3FilterAccepted=true) const
	Gets all HLT path names. More...

const edm::ParameterSetID &	psetID () const

void	setPSetID (const edm::ParameterSetID &psetId)
	set the psetid of the trigger process More...

TriggerObject	triggerObject ()
	Gets the pat::TriggerObject (parent class) More...

	TriggerObjectStandAlone ()
	Constructors and Destructor. More...

	TriggerObjectStandAlone (const TriggerObject &trigObj)
	Constructor from pat::TriggerObject. More...

	TriggerObjectStandAlone (const trigger::TriggerObject &trigObj)
	Constructor from trigger::TriggerObject. More...

	TriggerObjectStandAlone (const reco::LeafCandidate &leafCand)
	Constructor from reco::Candidate. More...

	TriggerObjectStandAlone (const reco::Particle::LorentzVector &vec, int id=0)
	Constructors from Lorentz-vectors and (optional) PDG ID. More...

	TriggerObjectStandAlone (const reco::Particle::PolarLorentzVector &vec, int id=0)

	TriggerObjectStandAlone (const TriggerObjectStandAlone &)=default

void	unpackFilterLabels (const std::vector< std::string > &labels)
	unpack filter labels from indices More...

void	unpackFilterLabels (const edm::EventBase &event, const edm::TriggerResults &res)
	unpack filter labels from indices More...

void	unpackNamesAndLabels (const edm::EventBase &event, const edm::TriggerResults &res)
	unpack both filter labels and trigger names More...

void	unpackPathNames (const edm::TriggerNames &names)
	unpack trigger names into indices More...

virtual	~TriggerObjectStandAlone ()
	Destructor. More...

Public Member Functions inherited from pat::TriggerObject
void	addFilterId (trigger::TriggerObjectType triggerObjectType)

void	addFilterId (int triggerObjectType)

void	addTriggerObjectType (trigger::TriggerObjectType triggerObjectType)
	Add a new trigger object type identifier. More...

void	addTriggerObjectType (int triggerObjectType)

const std::string &	collection () const
	Get the label of the collection the trigger object originates from. More...

std::vector< int >	filterIds () const

bool	hasFilterId (trigger::TriggerObjectType triggerObjectType) const

bool	hasFilterId (int triggerObjectType) const

bool	hasTriggerObjectType (trigger::TriggerObjectType triggerObjectType) const
	Checks, if a certain trigger object type identifier is assigned. More...

bool	hasTriggerObjectType (int triggerObjectType) const

bool	id (trigger::TriggerObjectType triggerObjectType) const

bool	id (int triggerObjectType) const

const l1extra::L1EmParticleRef	origL1EmRef () const

const l1extra::L1EtMissParticleRef	origL1EtMissRef () const

const L1GctEmCand *	origL1GctEmCand () const

const L1GctEtHad *	origL1GctEtHad () const

const L1GctEtMiss *	origL1GctEtMiss () const

const L1GctEtTotal *	origL1GctEtTotal () const

const L1GctHtMiss *	origL1GctHtMiss () const

const L1GctJetCand *	origL1GctJetCand () const

const L1MuGMTExtendedCand *	origL1GmtMuonCand () const

const l1extra::L1JetParticleRef	origL1JetRef () const

const l1extra::L1MuonParticleRef	origL1MuonRef () const

const reco::Candidate *	origObjCand () const

const reco::CandidateBaseRef &	origObjRef () const
	Special methods for 'l1extra' particles. More...

void	setCollection (const std::string &collName)
	Methods. More...

void	setCollection (const edm::InputTag &collName)

	TriggerObject ()
	Constructors and Destructor. More...

	TriggerObject (const trigger::TriggerObject &trigObj)
	Constructor from trigger::TriggerObject. More...

	TriggerObject (const reco::LeafCandidate &leafCand)
	Constructors from base class object. More...

	TriggerObject (const reco::CandidateBaseRef &candRef)
	Constructors from base candidate reference (for 'l1extra' particles) More...

	TriggerObject (const reco::Particle::LorentzVector &vec, int id=0)
	Constructors from Lorentz-vectors and (optional) PDG ID. More...

	TriggerObject (const reco::Particle::PolarLorentzVector &vec, int id=0)

std::vector< int >	triggerObjectTypes () const
	Get all trigger object type identifiers. More...

bool	type (trigger::TriggerObjectType triggerObjectType) const
	Calls 'hasTriggerObjectType(...)'. More...

bool	type (int triggerObjectType) const

virtual	~TriggerObject ()
	Destructor. More...

Public Member Functions inherited from reco::LeafCandidate
virtual Vector	boostToCM () const final

virtual int	charge () const final
	electric charge More...

virtual LeafCandidate *	clone () const
	returns a clone of the Candidate object More...

void	construct (int qx3, float pt, float eta, float phi, float mass, const Point &vtx, int pdgId, int status)

virtual const Candidate *	daughter (size_type) const
	return daughter at a given position (throws an exception) More...

virtual Candidate *	daughter (size_type)
	return daughter at a given position (throws an exception) More...

virtual Candidate *	daughter (const std::string &s)
	return daughter with a specified role name More...

virtual const Candidate *	daughter (const std::string &s) const
	return daughter with a specified role name More...

virtual double	energy () const final
	energy More...

virtual double	et () const final
	transverse energy More...

virtual double	et2 () const final
	transverse energy squared (use this for cut!) More...

virtual double	eta () const final
	momentum pseudorapidity More...

virtual void	fillVertexCovariance (CovarianceMatrix &v) const
	fill SMatrix More...

template<typename T >
T	get () const
	get a component More...

template<typename T , typename Tag >
T	get () const
	get a component More...

template<typename T >
T	get (size_type i) const
	get a component More...

template<typename T , typename Tag >
T	get (size_type i) const
	get a component More...

virtual bool	hasMasterClone () const

virtual bool	hasMasterClonePtr () const

virtual bool	isCaloMuon () const

virtual bool	isConvertedPhoton () const

virtual bool	isElectron () const

virtual bool	isGlobalMuon () const

virtual bool	isJet () const

virtual bool	isMuon () const

virtual bool	isPhoton () const

virtual bool	isStandAloneMuon () const

virtual bool	isTrackerMuon () const

	LeafCandidate ()

	LeafCandidate (const Candidate &c)

template<typename... Args>
	LeafCandidate (Args &&...args)

	LeafCandidate (LeafCandidate &rh)

	LeafCandidate (LeafCandidate &&)=default

	LeafCandidate (LeafCandidate const &)=default

virtual bool	longLived () const final
	is long lived? More...

virtual double	mass () const final
	mass More...

virtual bool	massConstraint () const final
	do mass constraint? More...

virtual double	massSqr () const final
	mass squared More...

virtual const CandidateBaseRef &	masterClone () const

virtual const CandidatePtr &	masterClonePtr () const

template<typename Ref >
Ref	masterRef () const
	cast master clone reference to a concrete type More...

virtual Vector	momentum () const final
	spatial momentum vector More...

virtual const Candidate *	mother (size_type) const
	return mother at a given position (throws an exception) More...

virtual double	mt () const final
	transverse mass More...

virtual double	mtSqr () const final
	transverse mass squared More...

template<typename T >
size_type	numberOf () const
	number of components More...

template<typename T , typename Tag >
size_type	numberOf () const
	number of components More...

virtual size_t	numberOfDaughters () const
	number of daughters More...

virtual size_t	numberOfMothers () const
	number of mothers More...

virtual size_t	numberOfSourceCandidatePtrs () const

LeafCandidate &	operator= (LeafCandidate &&)=default

LeafCandidate &	operator= (LeafCandidate const &)=default

virtual double	p () const final
	magnitude of momentum vector More...

virtual const LorentzVector &	p4 () const final
	four-momentum Lorentz vector More...

virtual int	pdgId () const final
	PDG identifier. More...

virtual double	phi () const final
	momentum azimuthal angle More...

virtual const PolarLorentzVector &	polarP4 () const final
	four-momentum Lorentz vector More...

virtual double	pt () const final
	transverse momentum More...

virtual double	px () const final
	x coordinate of momentum vector More...

virtual double	py () const final
	y coordinate of momentum vector More...

virtual double	pz () const final
	z coordinate of momentum vector More...

virtual double	rapidity () const final
	rapidity More...

virtual void	setCharge (Charge q) final
	set electric charge More...

virtual void	setLongLived () final

virtual void	setMass (double m) final
	set particle mass More...

virtual void	setMassConstraint () final

virtual void	setP4 (const LorentzVector &p4) final
	set 4-momentum More...

virtual void	setP4 (const PolarLorentzVector &p4) final
	set 4-momentum More...

virtual void	setPdgId (int pdgId) final

virtual void	setPz (double pz) final

virtual void	setStatus (int status) final
	set status word More...

virtual void	setThreeCharge (Charge qx3) final
	set electric charge More...

virtual void	setVertex (const Point &vertex)
	set vertex More...

virtual CandidatePtr	sourceCandidatePtr (size_type i) const

virtual int	status () const final
	status word More...

virtual double	theta () const final
	momentum polar angle More...

virtual int	threeCharge () const final
	electric charge More...

virtual const Point &	vertex () const
	vertex position (overwritten by PF...) More...

virtual double	vertexChi2 () const
	chi-squares More...

virtual double	vertexCovariance (int i, int j) const
	(i, j)-th element of error matrix, i, j = 0, ... 2 More...

CovarianceMatrix	vertexCovariance () const final
	return SMatrix More...

virtual double	vertexNdof () const

virtual double	vertexNormalizedChi2 () const
	chi-squared divided by n.d.o.f. More...

virtual double	vx () const
	x coordinate of vertex position More...

virtual double	vy () const
	y coordinate of vertex position More...

virtual double	vz () const
	z coordinate of vertex position More...

virtual double	y () const final
	rapidity More...

virtual	~LeafCandidate ()
	destructor More...

Public Member Functions inherited from reco::Candidate
const_iterator	begin () const
	first daughter const_iterator More...

iterator	begin ()
	first daughter iterator More...

virtual const Track *	bestTrack () const

	Candidate ()
	default constructor More...

virtual float	dxyError () const
	uncertainty on dxy More...

virtual float	dzError () const
	uncertainty on dz More...

const_iterator	end () const
	last daughter const_iterator More...

iterator	end ()
	last daughter iterator More...

template<typename T >
T	get () const
	get a component More...

template<typename T , typename Tag >
T	get () const
	get a component More...

template<typename T >
T	get (size_type i) const
	get a component More...

template<typename T , typename Tag >
T	get (size_type i) const
	get a component More...

template<typename Ref >
Ref	masterRef () const
	cast master clone reference to a concrete type More...

template<typename T >
size_type	numberOf () const
	number of components More...

template<typename T , typename Tag >
size_type	numberOf () const
	number of components More...

virtual void	setSourceCandidatePtr (const CandidatePtr &ptr)
	Set the ptr to the source Candidate. More...

virtual	~Candidate ()
	destructor More...

Private Member Functions
void	addFilterOrCondition (const std::string &name)
	Adds a new HLT filter label or L1 condition name. More...

void	addPathOrAlgorithm (const std::string &name, bool pathLastFilterAccepted, bool pathL3FilterAccepted)
	Adds a new HLT path or L1 algorithm name. More...

bool	checkIfFiltersAreUnpacked (bool throwIfPacked=true) const
	Check if trigger names have been packed by calling packFilterLabels() and not yet unpacked. More...

bool	checkIfPathsAreUnpacked (bool throwIfPacked=true) const
	Check if trigger names have been packed by calling packPathNames() and not yet unpacked. More...

const std::vector< std::string > &	filtersOrConditions () const
	Gets all HLT filter labels or L1 condition names. More...

bool	hasAnyName (const std::string &name, const std::vector< std::string > &nameVec) const
	Private methods. More...

bool	hasFilterOrCondition (const std::string &name) const
	Checks, if a certain HLT filter label or L1 condition name is assigned. More...

bool	hasL3Filter () const

bool	hasLastFilter () const
	Check, if the usage indicator vectors have been filled. More...

bool	hasPathOrAlgorithm (const std::string &name, bool pathLastFilterAccepted, bool pathL3FilterAccepted) const
	Checks, if a certain HLT path or L1 algorithm name is assigned. More...

std::vector< std::string >	pathsOrAlgorithms (bool pathLastFilterAccepted, bool pathL3FilterAccepted) const
	Gets all HLT path or L1 algorithm names. More...

Private Attributes
std::vector< uint16_t >	filterLabelIndices_

std::vector< std::string >	filterLabels_
	Vector of labels of all HLT filters or names of L1 conditions the trigger objects has been used in. More...

std::vector< uint16_t >	pathIndices_

std::vector< bool >	pathL3FilterAccepted_

std::vector< bool >	pathLastFilterAccepted_

std::vector< std::string >	pathNames_
	Vector of names of all HLT paths or L1 algorithms the trigger objects has been used in. More...

edm::ParameterSetID	psetId_

Static Private Attributes
static const char	wildcard_ = '*'
	Constants. More...

Additional Inherited Members
Public Types inherited from reco::LeafCandidate
typedef int	Charge
	electric charge type More...

typedef CandidateCollection	daughters
	collection of daughter candidates More...

typedef unsigned int	index

typedef math::XYZTLorentzVector	LorentzVector
	Lorentz vector. More...

typedef math::XYZPoint	Point
	point in the space More...

typedef math::PtEtaPhiMLorentzVector	PolarLorentzVector
	Lorentz vector. More...

typedef math::XYZVector	Vector
	point in the space More...

Public Types inherited from reco::Candidate
enum	{ dimension = 3 }

enum	{ size = dimension * (dimension + 1)/2 }
	matix size More...

typedef int	Charge
	electric charge type More...

typedef candidate::const_iterator	const_iterator

typedef math::Error< dimension >::type	CovarianceMatrix
	covariance error matrix (3x3) More...

typedef unsigned int	index
	index type More...

typedef candidate::iterator	iterator

typedef math::XYZTLorentzVector	LorentzVector
	Lorentz vector. More...

typedef math::XYZPoint	Point
	point in the space More...

typedef math::PtEtaPhiMLorentzVector	PolarLorentzVector
	Lorentz vector. More...

typedef size_t	size_type

typedef math::XYZVector	Vector
	point in the space More...

Detailed Description

Analysis-level trigger object class (stand-alone)

TriggerObjectStandAlone implements a container for trigger objects' information within the 'pat' namespace. These Trigger objects keep also information on filters and paths to be saved independently or embedded into PAT objects. The TriggerObjectStandAlone is also the data format used in the PAT trigger object matching. For detailed information, consult https://twiki.cern.ch/twiki/bin/view/CMS/SWGuidePATTrigger#TriggerObjectStandAlone

Author: Volker Adler

Definition at line 32 of file TriggerObjectStandAlone.h.

Constructor & Destructor Documentation

TriggerObjectStandAlone::TriggerObjectStandAlone ( )

Constructors and Destructor.

Default constructor

Definition at line 30 of file TriggerObjectStandAlone.cc.

References filterLabelIndices_, filterLabels_, pathL3FilterAccepted_, pathLastFilterAccepted_, and pathNames_.

                                                  :
   TriggerObject()
 {
   filterLabels_.clear();
   filterLabelIndices_.clear();
   pathNames_.clear();
   pathLastFilterAccepted_.clear();
   pathL3FilterAccepted_.clear();
 }

TriggerObjectStandAlone::TriggerObjectStandAlone ( const TriggerObject & trigObj )

Constructor from pat::TriggerObject.

Definition at line 42 of file TriggerObjectStandAlone.cc.

References filterLabelIndices_, filterLabels_, pathL3FilterAccepted_, pathLastFilterAccepted_, and pathNames_.

                                                                                 :
   TriggerObject( trigObj )
 {
   filterLabels_.clear();
   filterLabelIndices_.clear();
   pathNames_.clear();
   pathLastFilterAccepted_.clear();
   pathL3FilterAccepted_.clear();
 }

TriggerObjectStandAlone::TriggerObjectStandAlone ( const trigger::TriggerObject & trigObj )

Constructor from trigger::TriggerObject.

Definition at line 54 of file TriggerObjectStandAlone.cc.

References filterLabelIndices_, filterLabels_, pathL3FilterAccepted_, pathLastFilterAccepted_, and pathNames_.

                                                                                        :
   TriggerObject( trigObj )
 {
   filterLabels_.clear();
   filterLabelIndices_.clear();
   pathNames_.clear();
   pathLastFilterAccepted_.clear();
   pathL3FilterAccepted_.clear();
 }

TriggerObjectStandAlone::TriggerObjectStandAlone ( const reco::LeafCandidate & leafCand )

Constructor from reco::Candidate.

Definition at line 66 of file TriggerObjectStandAlone.cc.

References filterLabelIndices_, filterLabels_, pathL3FilterAccepted_, pathLastFilterAccepted_, and pathNames_.

                                                                                      :
   TriggerObject( leafCand )
 {
   filterLabels_.clear();
   filterLabelIndices_.clear();
   pathNames_.clear();
   pathLastFilterAccepted_.clear();
   pathL3FilterAccepted_.clear();
 }

TriggerObjectStandAlone::TriggerObjectStandAlone	(	const reco::Particle::LorentzVector &	vec,
		int	id = `0`
	)

Constructors from Lorentz-vectors and (optional) PDG ID.

Definition at line 78 of file TriggerObjectStandAlone.cc.

References filterLabelIndices_, filterLabels_, pathL3FilterAccepted_, pathLastFilterAccepted_, and pathNames_.

                                                                                                 :
   TriggerObject( vec, id )
 {
   filterLabels_.clear();
   filterLabelIndices_.clear();
   pathNames_.clear();
   pathLastFilterAccepted_.clear();
   pathL3FilterAccepted_.clear();
 }

TriggerObjectStandAlone::TriggerObjectStandAlone	(	const reco::Particle::PolarLorentzVector &	vec,
		int	id = `0`
	)

Definition at line 87 of file TriggerObjectStandAlone.cc.

References filterLabelIndices_, filterLabels_, pathL3FilterAccepted_, pathLastFilterAccepted_, and pathNames_.

                                                                                                      :
   TriggerObject( vec, id )
 {
   filterLabels_.clear();
   filterLabelIndices_.clear();
   pathNames_.clear();
   pathLastFilterAccepted_.clear();
   pathL3FilterAccepted_.clear();
 }

pat::TriggerObjectStandAlone::TriggerObjectStandAlone ( const TriggerObjectStandAlone & )

default

virtual pat::TriggerObjectStandAlone::~TriggerObjectStandAlone ( )

inlinevirtual

Destructor.

Definition at line 106 of file TriggerObjectStandAlone.h.

106 {};

Member Function Documentation

void pat::TriggerObjectStandAlone::addAlgorithmName	(	const std::string &	algorithmName,
		bool	algoCondAccepted = `true`
	)

inline

Adds a new L1 algorithm name.

Definition at line 121 of file TriggerObjectStandAlone.h.

121 { addPathOrAlgorithm( algorithmName, algoCondAccepted, false ); };

pat::TriggerObjectStandAlone::addPathOrAlgorithm

void addPathOrAlgorithm(const std::string &name, bool pathLastFilterAccepted, bool pathL3FilterAccepted)

Adds a new HLT path or L1 algorithm name.

Definition: TriggerObjectStandAlone.cc:148

void pat::TriggerObjectStandAlone::addConditionName ( const std::string & conditionName )

inline

Adds a new L1 condition name.

Definition at line 117 of file TriggerObjectStandAlone.h.

117 { addFilterOrCondition( conditionName ); };

pat::TriggerObjectStandAlone::addFilterOrCondition

void addFilterOrCondition(const std::string &name)

Adds a new HLT filter label or L1 condition name.

Definition: TriggerObjectStandAlone.h:68

void pat::TriggerObjectStandAlone::addFilterLabel ( const std::string & filterLabel )

inline

Adds a new HLT filter label.

Definition at line 115 of file TriggerObjectStandAlone.h.

Referenced by pat::PATTriggerProducer::produce().

115 { addFilterOrCondition( filterLabel ); };

pat::TriggerObjectStandAlone::addFilterOrCondition

void addFilterOrCondition(const std::string &name)

Adds a new HLT filter label or L1 condition name.

Definition: TriggerObjectStandAlone.h:68

void pat::TriggerObjectStandAlone::addFilterOrCondition ( const std::string & name )

inlineprivate

Adds a new HLT filter label or L1 condition name.

Definition at line 68 of file TriggerObjectStandAlone.h.

References dataset::name, and AlCaHLTBitMon_QueryRunRegistry::string.

68 { if ( ! hasFilterOrCondition( name ) ) filterLabels_.push_back( name ); };

pat::TriggerObjectStandAlone::filterLabels_

std::vector< std::string > filterLabels_

Vector of labels of all HLT filters or names of L1 conditions the trigger objects has been used in...

Definition: TriggerObjectStandAlone.h:39

pat::TriggerObjectStandAlone::hasFilterOrCondition

bool hasFilterOrCondition(const std::string &name) const

Checks, if a certain HLT filter label or L1 condition name is assigned.

Definition: TriggerObjectStandAlone.cc:198

dataset.name

name

Definition: dataset.py:45

void pat::TriggerObjectStandAlone::addPathName	(	const std::string &	pathName,
		bool	pathLastFilterAccepted = `true`,
		bool	pathL3FilterAccepted = `true`
	)

inline

Adds a new HLT path name.

Definition at line 119 of file TriggerObjectStandAlone.h.

Referenced by pat::PATTriggerProducer::produce().

119 { addPathOrAlgorithm( pathName, pathLastFilterAccepted, pathL3FilterAccepted ); };

pat::TriggerObjectStandAlone::addPathOrAlgorithm

void addPathOrAlgorithm(const std::string &name, bool pathLastFilterAccepted, bool pathL3FilterAccepted)

Adds a new HLT path or L1 algorithm name.

Definition: TriggerObjectStandAlone.cc:148

void TriggerObjectStandAlone::addPathOrAlgorithm	(	const std::string &	name,
		bool	pathLastFilterAccepted,
		bool	pathL3FilterAccepted
	)

private

Adds a new HLT path or L1 algorithm name.

Definition at line 148 of file TriggerObjectStandAlone.cc.

References checkIfPathsAreUnpacked(), hasPathOrAlgorithm(), dataset::name, pathL3FilterAccepted_, pathLastFilterAccepted_, and pathNames_.

 {
   checkIfPathsAreUnpacked();
 
   // Check, if path is already assigned
   if ( ! hasPathOrAlgorithm( name, false, false ) ) {
     // The path itself
     pathNames_.push_back( name );
     // The corresponding usage of the trigger objects
     pathLastFilterAccepted_.push_back( pathLastFilterAccepted );
     pathL3FilterAccepted_.push_back( pathL3FilterAccepted );
   // Enable status updates
   } else if ( pathLastFilterAccepted || pathL3FilterAccepted ) {
     // Search for path
     unsigned index( 0 );
     while ( index < pathNames_.size() ) {
       if ( pathNames_.at( index ) == name ) break;
       ++index;
     }
     // Status update
     if ( index < pathNames_.size() ) {
       pathLastFilterAccepted_.at( index ) = pathLastFilterAccepted_.at( index ) || pathLastFilterAccepted;
       pathL3FilterAccepted_.at( index )   = pathL3FilterAccepted_.at( index )   || pathL3FilterAccepted;
     }
   }
 }

bool pat::TriggerObjectStandAlone::algo	(	const std::string &	algorithmName,
		unsigned	algoCondAccepted = `1`
	)		const

inline

Calls 'hasAlgorithmName(...)'.

Definition at line 159 of file TriggerObjectStandAlone.h.

159 { return hasAlgorithmName( algorithmName, bool( algoCondAccepted ) ); };

pat::TriggerObjectStandAlone::hasAlgorithmName

bool hasAlgorithmName(const std::string &algorithmName, bool algoCondAccepted=true) const

Checks, if a certain L1 algorithm name is assigned.

Definition: TriggerObjectStandAlone.h:139

std::vector< std::string > pat::TriggerObjectStandAlone::algorithmNames ( bool algoCondAccepted = true ) const

inline

Gets all L1 algorithm names.

Definition at line 129 of file TriggerObjectStandAlone.h.

129 { return pathsOrAlgorithms( algoCondAccepted, false ); };

pat::TriggerObjectStandAlone::pathsOrAlgorithms

std::vector< std::string > pathsOrAlgorithms(bool pathLastFilterAccepted, bool pathL3FilterAccepted) const

Gets all HLT path or L1 algorithm names.

Definition: TriggerObjectStandAlone.cc:177

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

Definition at line 399 of file TriggerObjectStandAlone.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), mps_fire::i, edm::ParameterSet::insert(), funct::m, gen::n, edm::EventBase::parameterSet(), and muonDTDigis_cfi::pset.

Referenced by packFilterLabels(), and unpackFilterLabels().

                                                                                                                                                              {
 
       // If TriggerNames was already created and cached here in the map,
       // then look it up and return that one
       AllLabelsMap::const_iterator iter =
          allLabelsMap.find(psetid);
       if (iter != allLabelsMap.end()) {
          return &iter->second;
       }
 
       auto   triggerNames= event.triggerNames(res); 
       edm::ParameterSet const* pset=nullptr;
       //getting the ParameterSet from the event ensures that the registry is filled
       if (nullptr!=(pset=event.parameterSet(psetid ))) {
     using namespace std;
     using namespace edm;
     using namespace trigger;
 
 
     const unsigned int n(triggerNames.size());
     std::set<std::string> saveTags;
     for (unsigned int i=0;i!=n; ++i) {
             if (pset->existsAs<vector<string> >(triggerNames.triggerName(i),true)) {
             auto modules = pset->getParameter<vector<string> >(triggerNames.triggerName(i));
         for(size_t m=0; m < modules.size(); m++){
             auto module=modules[m];
             auto moduleStrip=module.front()!='-' ? module : module.substr(1);
  
             if (pset->exists(moduleStrip)) {
             auto modulePSet= pset->getParameterSet(moduleStrip);
             if (modulePSet.existsAs<bool>("saveTags",true) and 
                 modulePSet.getParameter<bool>("saveTags") ) {
                 saveTags.insert(moduleStrip);
             }
             }   
         }
             }
     }
     std::vector<std::string> allModules(saveTags.begin(),saveTags.end());
          std::pair<AllLabelsMap::iterator, bool> ret =
                allLabelsMap.insert(std::pair<edm::ParameterSetID, std::vector<std::string> >(psetid, allModules));
          return &(ret.first->second);
       }
       return 0;
    }

bool TriggerObjectStandAlone::checkIfFiltersAreUnpacked ( bool throwIfPacked = true ) const

private

Check if trigger names have been packed by calling packFilterLabels() and not yet unpacked.

Definition at line 277 of file TriggerObjectStandAlone.cc.

References Exception, and filterLabelIndices_.

Referenced by hasFilterOrCondition().

                                                                                 {
    bool unpacked = filterLabelIndices_.empty();
    if (!unpacked && throwIfPacked) throw cms::Exception("RuntimeError", "This TriggerObjectStandAlone object has packed trigger filter labels. Before accessing path names you must call unpackFilterLabels with an edm::EventBase object. Both the edm::Event or fwlite::Event are derived from edm::EventBase and can be passed\n");
    return unpacked;
 }

bool TriggerObjectStandAlone::checkIfPathsAreUnpacked ( bool throwIfPacked = true ) const

private

Check if trigger names have been packed by calling packPathNames() and not yet unpacked.

Definition at line 272 of file TriggerObjectStandAlone.cc.

References Exception, pathIndices_, and pathNames_.

Referenced by addPathOrAlgorithm(), hasPathOrAlgorithm(), and pathsOrAlgorithms().

                                                                               {
    bool unpacked = (!pathNames_.empty() || pathIndices_.empty());
    if (!unpacked && throwIfPacked) throw cms::Exception("RuntimeError", "This TriggerObjectStandAlone object has packed trigger path names. Before accessing path names you must call unpackPathNames with an edm::TriggerNames object. You can get the latter from the edm::Event or fwlite::Event and the TriggerResults\n");
    return unpacked;
 }

virtual bool pat::TriggerObjectStandAlone::coll ( const std::string & collName ) const

inlinevirtual

Calls 'hasCollection(...)' (method override)

Reimplemented from pat::TriggerObject.

Definition at line 161 of file TriggerObjectStandAlone.h.

161 { return hasCollection( collName ); };

pat::TriggerObjectStandAlone::hasCollection

virtual bool hasCollection(const std::string &collName) const

Checks, if a certain label of original collection is assigned (method overrides)

Definition: TriggerObjectStandAlone.cc:248

bool pat::TriggerObjectStandAlone::cond ( const std::string & conditionName ) const

inline

Calls 'hasConditionName(...)'.

Definition at line 155 of file TriggerObjectStandAlone.h.

155 { return hasConditionName( conditionName ); };

pat::TriggerObjectStandAlone::hasConditionName

bool hasConditionName(const std::string &conditionName) const

Checks, if a certain L1 condition name is assigned.

Definition: TriggerObjectStandAlone.h:135

const std::vector< std::string >& pat::TriggerObjectStandAlone::conditionNames ( ) const

inline

Gets all L1 condition names.

Definition at line 125 of file TriggerObjectStandAlone.h.

125 { return filtersOrConditions(); };

pat::TriggerObjectStandAlone::filtersOrConditions

const std::vector< std::string > & filtersOrConditions() const

Gets all HLT filter labels or L1 condition names.

Definition: TriggerObjectStandAlone.h:72

TriggerObjectStandAlone pat::TriggerObjectStandAlone::copy ( ) const

inline

Methods.

Definition at line 110 of file TriggerObjectStandAlone.h.

                                            {
         return *this;
       }

bool pat::TriggerObjectStandAlone::filter ( const std::string & filterLabel ) const

inline

Calls 'hasFilterLabel(...)'.

Special methods for the cut string parser

argument types usable in the cut string parser
short names for readable configuration files

Definition at line 153 of file TriggerObjectStandAlone.h.

Referenced by Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::filter(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::find(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::setDataAccessor(), and Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::switchCenterView().

153 { return hasFilterLabel( filterLabel ); };

pat::TriggerObjectStandAlone::hasFilterLabel

bool hasFilterLabel(const std::string &filterLabel) const

Checks, if a certain HLT filter label is assigned.

Definition: TriggerObjectStandAlone.h:133

const std::vector< std::string >& pat::TriggerObjectStandAlone::filterLabels ( ) const

inline

Gets all HLT filter labels.

Definition at line 123 of file TriggerObjectStandAlone.h.

123 { return filtersOrConditions(); };

pat::TriggerObjectStandAlone::filtersOrConditions

const std::vector< std::string > & filtersOrConditions() const

Gets all HLT filter labels or L1 condition names.

Definition: TriggerObjectStandAlone.h:72

const std::vector< std::string >& pat::TriggerObjectStandAlone::filtersOrConditions ( ) const

inlineprivate

Gets all HLT filter labels or L1 condition names.

Definition at line 72 of file TriggerObjectStandAlone.h.

References AlCaHLTBitMon_QueryRunRegistry::string.

72 { checkIfFiltersAreUnpacked(); return filterLabels_; };

pat::TriggerObjectStandAlone::checkIfFiltersAreUnpacked

bool checkIfFiltersAreUnpacked(bool throwIfPacked=true) const

Check if trigger names have been packed by calling packFilterLabels() and not yet unpacked...

Definition: TriggerObjectStandAlone.cc:277

pat::TriggerObjectStandAlone::filterLabels_

std::vector< std::string > filterLabels_

Vector of labels of all HLT filters or names of L1 conditions the trigger objects has been used in...

Definition: TriggerObjectStandAlone.h:39

bool pat::TriggerObjectStandAlone::hasAlgoCondAccepted ( ) const

inline

Definition at line 145 of file TriggerObjectStandAlone.h.

145 { return hasLastFilter(); };

pat::TriggerObjectStandAlone::hasLastFilter

bool hasLastFilter() const

Check, if the usage indicator vectors have been filled.

Definition: TriggerObjectStandAlone.h:80

bool pat::TriggerObjectStandAlone::hasAlgorithmName	(	const std::string &	algorithmName,
		bool	algoCondAccepted = `true`
	)		const

inline

Checks, if a certain L1 algorithm name is assigned.

Definition at line 139 of file TriggerObjectStandAlone.h.

References AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by pat::PATObject< ObjectType >::triggerObjectMatchByAlgorithm(), and pat::PATObject< ObjectType >::triggerObjectMatchesByAlgorithm().

139 { return hasPathOrAlgorithm( algorithmName, algoCondAccepted, false ); };

pat::TriggerObjectStandAlone::hasPathOrAlgorithm

bool hasPathOrAlgorithm(const std::string &name, bool pathLastFilterAccepted, bool pathL3FilterAccepted) const

Checks, if a certain HLT path or L1 algorithm name is assigned.

Definition: TriggerObjectStandAlone.cc:210

bool TriggerObjectStandAlone::hasAnyName	(	const std::string &	name,
		const std::vector< std::string > &	nameVec
	)		const

private

Private methods.

Checks a string vector for occurence of a certain string, incl. wild-card mechanism

Definition at line 102 of file TriggerObjectStandAlone.cc.

References runEdmFileComparison::failed, split, AlCaHLTBitMon_QueryRunRegistry::string, and wildcard_.

Referenced by hasCollection(), hasFilterOrCondition(), and hasPathOrAlgorithm().

 {
   // Special cases first
   // Always false for empty vector to check
   if ( nameVec.empty() ) return false;
   // Always true for general wild-card(s)
   if ( name.find_first_not_of( wildcard_ ) == std::string::npos ) return true;
   // Split name to evaluate in parts, seperated by wild-cards
   std::vector< std::string > namePartsVec;
   boost::split( namePartsVec, name, boost::is_any_of( std::string( 1, wildcard_ ) ), boost::token_compress_on );
   // Iterate over vector of names to search
   for ( std::vector< std::string >::const_iterator iVec = nameVec.begin(); iVec != nameVec.end(); ++iVec ) {
     // Not failed yet
     bool failed( false );
     // Start searching at the first character
     size_type index( 0 );
     // Iterate over evaluation name parts
     for ( std::vector< std::string >::const_iterator iName = namePartsVec.begin(); iName != namePartsVec.end(); ++iName ) {
       // Empty parts due to
       // - wild-card at beginning/end or
       // - multiple wild-cards (should be supressed by 'boost::token_compress_on')
       if ( iName->length() == 0 ) continue;
       // Search from current index and
       // set index to found occurence
       index = iVec->find( *iName, index );
       // Failed and exit loop, if
       // - part not found
       // - part at beginning not found there
       if ( index == std::string::npos || ( iName == namePartsVec.begin() && index > 0 ) ) {
         failed = true;
         break;
       }
       // Increase index by length of found part
       index += iName->length();
     }
     // Failed, if end of name not reached
     if ( index < iVec->length() && namePartsVec.back().length() != 0 ) failed = true;
     // Match found!
     if ( ! failed ) return true;
   }
   // No match found!
   return false;
 }

bool TriggerObjectStandAlone::hasCollection ( const std::string & collName ) const

virtual

Checks, if a certain label of original collection is assigned (method overrides)

Reimplemented from pat::TriggerObject.

Definition at line 248 of file TriggerObjectStandAlone.cc.

References pat::TriggerObject::collection(), hasAnyName(), pat::TriggerObject::hasCollection(), edm::InputTag::instance(), edm::InputTag::label(), edm::InputTag::process(), and wildcard_.

Referenced by pat::PATTriggerProducer::produce(), pat::PATObject< ObjectType >::triggerObjectMatchByCollection(), and pat::PATObject< ObjectType >::triggerObjectMatchesByCollection().

 {
   // Move to wild-card parser, if needed only
   if ( collName.find( wildcard_ ) != std::string::npos ) {
     // True, if collection name is simply fine
     if ( hasAnyName( collName, std::vector< std::string >( 1, collection() ) ) ) return true;
     // Check, if collection name possibly fits in an edm::InputTag approach
     const edm::InputTag collectionTag( collection() );
     const edm::InputTag collTag( collName );
     // If evaluated collection tag contains a process name, it must have been found already by identity check
     if ( collTag.process().empty() ) {
       // Check instance ...
       if ( ( collTag.instance().empty() && collectionTag.instance().empty() ) || hasAnyName( collTag.instance(), std::vector< std::string >( 1, collectionTag.instance() ) ) ) {
         // ... and label
         return hasAnyName( collTag.label(), std::vector< std::string >( 1, collectionTag.label() ) );
       }
     }
     return false;
   }
   // Use parent class's method otherwise
   return TriggerObject::hasCollection( collName );
 }

virtual bool pat::TriggerObjectStandAlone::hasCollection ( const edm::InputTag & collName ) const

inlinevirtual

Reimplemented from pat::TriggerObject.

Definition at line 142 of file TriggerObjectStandAlone.h.

References edm::InputTag::encode(), and hasCollection().

Referenced by hasCollection().

142 { return hasCollection( collName.encode() ); };

pat::TriggerObjectStandAlone::hasCollection

virtual bool hasCollection(const std::string &collName) const

Checks, if a certain label of original collection is assigned (method overrides)

Definition: TriggerObjectStandAlone.cc:248

edm::InputTag::encode

std::string encode() const

Definition: InputTag.cc:166

bool pat::TriggerObjectStandAlone::hasConditionName ( const std::string & conditionName ) const

inline

Checks, if a certain L1 condition name is assigned.

Definition at line 135 of file TriggerObjectStandAlone.h.

Referenced by pat::PATObject< ObjectType >::triggerObjectMatchByCondition(), and pat::PATObject< ObjectType >::triggerObjectMatchesByCondition().

135 { return hasFilterOrCondition( conditionName ); };

pat::TriggerObjectStandAlone::hasFilterOrCondition

bool hasFilterOrCondition(const std::string &name) const

Checks, if a certain HLT filter label or L1 condition name is assigned.

Definition: TriggerObjectStandAlone.cc:198

bool pat::TriggerObjectStandAlone::hasFilterLabel ( const std::string & filterLabel ) const

inline

Checks, if a certain HLT filter label is assigned.

Definition at line 133 of file TriggerObjectStandAlone.h.

Referenced by pat::PATObject< ObjectType >::triggerObjectMatchByFilter(), and pat::PATObject< ObjectType >::triggerObjectMatchesByFilter().

133 { return hasFilterOrCondition( filterLabel ); };

pat::TriggerObjectStandAlone::hasFilterOrCondition

bool hasFilterOrCondition(const std::string &name) const

Checks, if a certain HLT filter label or L1 condition name is assigned.

Definition: TriggerObjectStandAlone.cc:198

bool TriggerObjectStandAlone::hasFilterOrCondition ( const std::string & name ) const

private

Checks, if a certain HLT filter label or L1 condition name is assigned.

Definition at line 198 of file TriggerObjectStandAlone.cc.

References checkIfFiltersAreUnpacked(), filterLabels_, spr::find(), hasAnyName(), dataset::name, and wildcard_.

 {
   checkIfFiltersAreUnpacked();
 
   // Move to wild-card parser, if needed
   if ( name.find( wildcard_ ) != std::string::npos ) return hasAnyName( name, filterLabels_ );
   // Return, if filter label is assigned
   return ( std::find( filterLabels_.begin(), filterLabels_.end(), name ) != filterLabels_.end() );
 }

bool pat::TriggerObjectStandAlone::hasL3Filter ( ) const

inlineprivate

Definition at line 81 of file TriggerObjectStandAlone.h.

Referenced by hasPathOrAlgorithm(), and pathsOrAlgorithms().

81 { return ( pathL3FilterAccepted_.size() > 0 && pathL3FilterAccepted_.size() == pathNames_.size() ); };

pat::TriggerObjectStandAlone::pathNames_

std::vector< std::string > pathNames_

Vector of names of all HLT paths or L1 algorithms the trigger objects has been used in...

Definition: TriggerObjectStandAlone.h:43

pat::TriggerObjectStandAlone::pathL3FilterAccepted_

std::vector< bool > pathL3FilterAccepted_

Definition: TriggerObjectStandAlone.h:54

bool pat::TriggerObjectStandAlone::hasLastFilter ( ) const

inlineprivate

Check, if the usage indicator vectors have been filled.

Definition at line 80 of file TriggerObjectStandAlone.h.

Referenced by hasPathOrAlgorithm(), and pathsOrAlgorithms().

80 { return ( pathLastFilterAccepted_.size() > 0 && pathLastFilterAccepted_.size() == pathNames_.size() ); };

pat::TriggerObjectStandAlone::pathNames_

std::vector< std::string > pathNames_

Vector of names of all HLT paths or L1 algorithms the trigger objects has been used in...

Definition: TriggerObjectStandAlone.h:43

pat::TriggerObjectStandAlone::pathLastFilterAccepted_

std::vector< bool > pathLastFilterAccepted_

Definition: TriggerObjectStandAlone.h:50

bool pat::TriggerObjectStandAlone::hasPathL3FilterAccepted ( ) const

inline

Definition at line 146 of file TriggerObjectStandAlone.h.

146 { return hasL3Filter(); };

pat::TriggerObjectStandAlone::hasL3Filter

bool hasL3Filter() const

Definition: TriggerObjectStandAlone.h:81

bool pat::TriggerObjectStandAlone::hasPathLastFilterAccepted ( ) const

inline

Checks, if the usage indicator vector has been filled.

Definition at line 144 of file TriggerObjectStandAlone.h.

144 { return hasLastFilter(); };

pat::TriggerObjectStandAlone::hasLastFilter

bool hasLastFilter() const

Check, if the usage indicator vectors have been filled.

Definition: TriggerObjectStandAlone.h:80

bool pat::TriggerObjectStandAlone::hasPathName	(	const std::string &	pathName,
		bool	pathLastFilterAccepted = `false`,
		bool	pathL3FilterAccepted = `true`
	)		const

inline

Checks, if a certain HLT path name is assigned.

Definition at line 137 of file TriggerObjectStandAlone.h.

Referenced by pat::PATObject< ObjectType >::triggerObjectMatchByPath(), and pat::PATObject< ObjectType >::triggerObjectMatchesByPath().

137 { return hasPathOrAlgorithm( pathName, pathLastFilterAccepted, pathL3FilterAccepted ); };

pat::TriggerObjectStandAlone::hasPathOrAlgorithm

bool hasPathOrAlgorithm(const std::string &name, bool pathLastFilterAccepted, bool pathL3FilterAccepted) const

Checks, if a certain HLT path or L1 algorithm name is assigned.

Definition: TriggerObjectStandAlone.cc:210

bool TriggerObjectStandAlone::hasPathOrAlgorithm	(	const std::string &	name,
		bool	pathLastFilterAccepted,
		bool	pathL3FilterAccepted
	)		const

private

Checks, if a certain HLT path or L1 algorithm name is assigned.

Definition at line 210 of file TriggerObjectStandAlone.cc.

References checkIfPathsAreUnpacked(), spr::find(), hasAnyName(), hasL3Filter(), hasLastFilter(), match(), dataset::name, pathL3FilterAccepted_, pathLastFilterAccepted_, pathNames_, pathsOrAlgorithms(), and wildcard_.

Referenced by addPathOrAlgorithm().

 {
   checkIfPathsAreUnpacked();
 
   // Move to wild-card parser, if needed
   if ( name.find( wildcard_ ) != std::string::npos ) return hasAnyName( name, pathsOrAlgorithms( pathLastFilterAccepted, pathL3FilterAccepted ) );
   // Deal with older PAT-tuples, where trigger object usage is not available
   if ( ! hasLastFilter() ) pathLastFilterAccepted = false;
   if ( ! hasL3Filter() ) pathL3FilterAccepted = false;
   // Check, if path name is assigned at all
   std::vector< std::string >::const_iterator match( std::find( pathNames_.begin(), pathNames_.end(), name ) );
   // False, if path name not assigned
   if ( match == pathNames_.end() ) return false;
   if ( ! pathLastFilterAccepted && ! pathL3FilterAccepted ) return true;
   bool foundLastFilter( pathLastFilterAccepted ? pathLastFilterAccepted_.at( match - pathNames_.begin() ) : true );
   bool foundL3Filter( pathL3FilterAccepted ? pathL3FilterAccepted_.at( match - pathNames_.begin() ) : true );
   // Return for assigned path name, if trigger object usage meets requirement
   return ( foundLastFilter && foundL3Filter );
 }

void TriggerObjectStandAlone::packFilterLabels	(	const edm::EventBase &	event,
		const edm::TriggerResults &	res
	)

Definition at line 376 of file TriggerObjectStandAlone.cc.

References allLabels(), and psetId_.

                                                                                                       {
    packFilterLabels(*allLabels(psetId_,event,res));
 }

void TriggerObjectStandAlone::packFilterLabels ( const std::vector< std::string > & labels )

pack filter labels into indices; note that the labels must be sorted!

Definition at line 330 of file TriggerObjectStandAlone.cc.

References Exception, filterLabelIndices_, filterLabels_, mps_fire::i, match(), eostools::move(), and gen::n.

                                                                                  {
     if (!filterLabelIndices_.empty()) {
         throw cms::Exception("RuntimeError", "Error, trying to pack filter labels for an already packed TriggerObjectStandAlone");
     }
     std::vector<std::string> unmatched;
     std::vector<uint16_t> indices;
     indices.reserve(filterLabels_.size());
    
     auto nStart = names.begin(), nEnd = names.end();
     for (unsigned int i = 0, n = filterLabels_.size(); i < n; ++i) {
         auto match = std::lower_bound(nStart, nEnd, filterLabels_[i]);
         if (match != nEnd && *match == filterLabels_[i]) {
             indices.push_back(match - nStart);
         } else {
             static std::atomic<int> _warn(0);
             if(++_warn < 5) edm::LogWarning("TriggerObjectStandAlone::packFilterLabels()") << "Warning: can't resolve '" << filterLabels_[i] << "' to a label index. idx: " << i <<std::endl;
             unmatched.push_back(std::move(filterLabels_[i]));
         }
     }
     std::sort(indices.begin(), indices.end()); // try reduce enthropy
     filterLabelIndices_.swap(indices);
     filterLabels_.swap(unmatched);
 }

void TriggerObjectStandAlone::packP4 ( )

reduce the precision on the 4-vector

Definition at line 381 of file TriggerObjectStandAlone.cc.

References reco::LeafCandidate::eta(), reco::LeafCandidate::mass(), reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), reco::LeafCandidate::setP4(), and edm::Hash< I >::smallHash().

                                      {
     setP4(reco::Particle::PolarLorentzVector(
                 MiniFloatConverter::reduceMantissaToNbitsRounding<14>(pt()),
                 MiniFloatConverter::reduceMantissaToNbitsRounding<11>(eta()),
                 MiniFloatConverter::reduceMantissaToNbits<11>(phi()),
                 MiniFloatConverter::reduceMantissaToNbitsRounding<8>(mass()) ));
 }

void TriggerObjectStandAlone::packPathNames ( const edm::TriggerNames & names )

pack trigger names into indices

Definition at line 285 of file TriggerObjectStandAlone.cc.

References reco::Candidate::end(), Exception, mps_fire::i, pat::TriggerObject::id(), gen::n, convertSQLiteXML::ok, pathIndices_, pathNames_, edm::TriggerNames::size(), and edm::TriggerNames::triggerIndex().

                                                                         {
     if (!pathIndices_.empty()) {
         if (!pathNames_.empty()) {
             throw cms::Exception("RuntimeError", "Error, trying to pack a partially packed TriggerObjectStandAlone");
         } else {
             return;
         }
     }
     bool ok = true;
     unsigned int n = pathNames_.size(), end = names.size();
     std::vector<uint16_t> indices(n); 
     for (unsigned int i = 0; i < n; ++i) {
         uint16_t id = names.triggerIndex(pathNames_[i]);
         if (id >= end) {
             static std::atomic<int> _warn(0);
             if (++_warn < 5) edm::LogWarning("TriggerObjectStandAlone::packPathNames()") << "Warning: can't resolve '" << pathNames_[i] << "' to a path index" << std::endl;
             ok = false; break;
         } else {
             indices[i] = id;
         }
     }
     if (ok) {
         pathIndices_.swap(indices);
         pathNames_.clear();
     }
 }

bool pat::TriggerObjectStandAlone::path	(	const std::string &	pathName,
		unsigned	pathLastFilterAccepted = `0`,
		unsigned	pathL3FilterAccepted = `1`
	)		const

inline

Calls 'hasPathName(...)'.

Definition at line 157 of file TriggerObjectStandAlone.h.

157 { return hasPathName( pathName, bool( pathLastFilterAccepted ), bool( pathL3FilterAccepted ) ); };

pat::TriggerObjectStandAlone::hasPathName

bool hasPathName(const std::string &pathName, bool pathLastFilterAccepted=false, bool pathL3FilterAccepted=true) const

Checks, if a certain HLT path name is assigned.

Definition: TriggerObjectStandAlone.h:137

std::vector< std::string > pat::TriggerObjectStandAlone::pathNames	(	bool	pathLastFilterAccepted = `false`,
		bool	pathL3FilterAccepted = `true`
	)		const

inline

Gets all HLT path names.

Definition at line 127 of file TriggerObjectStandAlone.h.

127 { return pathsOrAlgorithms( pathLastFilterAccepted, pathL3FilterAccepted ); };

pat::TriggerObjectStandAlone::pathsOrAlgorithms

std::vector< std::string > pathsOrAlgorithms(bool pathLastFilterAccepted, bool pathL3FilterAccepted) const

Gets all HLT path or L1 algorithm names.

Definition: TriggerObjectStandAlone.cc:177

std::vector< std::string > TriggerObjectStandAlone::pathsOrAlgorithms	(	bool	pathLastFilterAccepted,
		bool	pathL3FilterAccepted
	)		const

private

Gets all HLT path or L1 algorithm names.

Definition at line 177 of file TriggerObjectStandAlone.cc.

References checkIfPathsAreUnpacked(), hasL3Filter(), hasLastFilter(), pathL3FilterAccepted_, pathLastFilterAccepted_, and pathNames_.

Referenced by hasPathOrAlgorithm().

 {
   checkIfPathsAreUnpacked();
 
   // Deal with older PAT-tuples, where trigger object usage is not available
   if ( ! hasLastFilter() ) pathLastFilterAccepted = false;
   if ( ! hasL3Filter() ) pathL3FilterAccepted = false;
   // All path names, if usage not restricted (not required or not available)
   if ( ! pathLastFilterAccepted && ! pathL3FilterAccepted ) return pathNames_;
   // Temp vector of path names
   std::vector< std::string > paths;
   // Loop over usage vector and fill corresponding paths into temp vector
   for ( unsigned iPath = 0; iPath < pathNames_.size(); ++iPath ) {
     if ( ( ! pathLastFilterAccepted || pathLastFilterAccepted_.at( iPath ) ) && ( ! pathL3FilterAccepted || pathL3FilterAccepted_.at( iPath ) ) ) paths.push_back( pathNames_.at( iPath ) ); // order matters in order to protect from empty vectors in old data
   }
   // Return temp vector
   return paths;
 }

const edm::ParameterSetID& pat::TriggerObjectStandAlone::psetID ( ) const

inline

Definition at line 166 of file TriggerObjectStandAlone.h.

References tablePrinter::labels, cscdqm::h::names, slimmedPatTrigger_cfi::packFilterLabels, and slimmedPatTrigger_cfi::packP4.

166 {return psetId_;}

pat::TriggerObjectStandAlone::psetId_

edm::ParameterSetID psetId_

Definition: TriggerObjectStandAlone.h:56

void pat::TriggerObjectStandAlone::setPSetID ( const edm::ParameterSetID & psetId )

inline

set the psetid of the trigger process

Definition at line 164 of file TriggerObjectStandAlone.h.

164 {psetId_=psetId;}

pat::TriggerObjectStandAlone::psetId_

edm::ParameterSetID psetId_

Definition: TriggerObjectStandAlone.h:56

TriggerObject TriggerObjectStandAlone::triggerObject ( )

Gets the pat::TriggerObject (parent class)

Definition at line 235 of file TriggerObjectStandAlone.cc.

References pat::TriggerObject::addTriggerObjectType(), pat::TriggerObject::collection(), mps_fire::i, reco::LeafCandidate::p4(), reco::LeafCandidate::pdgId(), pat::TriggerObject::setCollection(), and pat::TriggerObject::triggerObjectTypes().

 {
   // Create a TriggerObjects
   TriggerObject theObj( p4(), pdgId() );
   // Set its collection and trigger objects types (no c'tor for that)
   theObj.setCollection( collection() );
   for ( size_t i = 0; i < triggerObjectTypes().size(); ++i ) theObj.addTriggerObjectType( triggerObjectTypes().at( i ) );
   // Return TriggerObject
   return theObj;
 }

void TriggerObjectStandAlone::unpackFilterLabels ( const std::vector< std::string > & labels )

unpack filter labels from indices

Definition at line 365 of file TriggerObjectStandAlone.cc.

References Exception, filterLabelIndices_, filterLabels_, mps_fire::i, funct::m, and gen::n.

Referenced by unpackFilterLabels(), and unpackNamesAndLabels().

                                                                                     {
     if (filterLabelIndices_.empty()) return;
 
     std::vector<std::string> mylabels(filterLabels_);
     for (unsigned int i = 0, n = filterLabelIndices_.size(), m = labels.size(); i < n; ++i) {
         if (filterLabelIndices_[i] >= m) throw cms::Exception("RuntimeError", "Error, filter label index out of bounds");
         mylabels.push_back(labels[filterLabelIndices_[i]]);
     }
     filterLabelIndices_.clear();
     filterLabels_.swap(mylabels);
 }

void TriggerObjectStandAlone::unpackFilterLabels	(	const edm::EventBase &	event,
		const edm::TriggerResults &	res
	)

unpack filter labels from indices

Definition at line 361 of file TriggerObjectStandAlone.cc.

References allLabels(), psetId_, and unpackFilterLabels().

                                                                                                          {
   unpackFilterLabels(*allLabels(psetId_,event,res));
 }

void TriggerObjectStandAlone::unpackNamesAndLabels	(	const edm::EventBase &	event,
		const edm::TriggerResults &	res
	)

unpack both filter labels and trigger names

Definition at line 354 of file TriggerObjectStandAlone.cc.

References edm::EventBase::triggerNames(), unpackFilterLabels(), and unpackPathNames().

 {
  unpackPathNames(event.triggerNames(res));
  unpackFilterLabels(event,res);
 
 }

void TriggerObjectStandAlone::unpackPathNames ( const edm::TriggerNames & names )

unpack trigger names into indices

Definition at line 312 of file TriggerObjectStandAlone.cc.

References reco::Candidate::end(), Exception, mps_fire::i, gen::n, pathIndices_, pathNames_, edm::TriggerNames::size(), and edm::TriggerNames::triggerName().

Referenced by unpackNamesAndLabels().

                                                                           {
     if (!pathNames_.empty()) {
         if (!pathIndices_.empty()) {
             throw cms::Exception("RuntimeError", "Error, trying to unpack a partially unpacked TriggerObjectStandAlone");
         } else {
             return;
         }
     }
     unsigned int n = pathIndices_.size(), end = names.size();
     std::vector<std::string> paths(n); 
     for (unsigned int i = 0; i < n; ++i) {
         if (pathIndices_[i] >= end) throw cms::Exception("RuntimeError", "Error, path index out of bounds");
         paths[i] = names.triggerName(pathIndices_[i]);
     }
     pathIndices_.clear();
     pathNames_.swap(paths);
 }

Member Data Documentation

std::vector< uint16_t > pat::TriggerObjectStandAlone::filterLabelIndices_

private

Definition at line 40 of file TriggerObjectStandAlone.h.

Referenced by checkIfFiltersAreUnpacked(), packFilterLabels(), TriggerObjectStandAlone(), and unpackFilterLabels().

std::vector< std::string > pat::TriggerObjectStandAlone::filterLabels_

private

Vector of labels of all HLT filters or names of L1 conditions the trigger objects has been used in.

Data Members Keeping the old names of the data members for backward compatibility, although they refer only to HLT objects.

Definition at line 39 of file TriggerObjectStandAlone.h.

Referenced by hasFilterOrCondition(), packFilterLabels(), TriggerObjectStandAlone(), and unpackFilterLabels().

std::vector< uint16_t > pat::TriggerObjectStandAlone::pathIndices_

private

Definition at line 44 of file TriggerObjectStandAlone.h.

Referenced by checkIfPathsAreUnpacked(), packPathNames(), and unpackPathNames().

std::vector< bool > pat::TriggerObjectStandAlone::pathL3FilterAccepted_

private

Vector alligned with 'pathNames_' of boolean indicating the usage of the trigger object An element is true, if the corresponding path succeeded and the trigger object was used in an L3 filter (HLT only) The vector is empty for data (size 0), if the according information is not available.

Definition at line 54 of file TriggerObjectStandAlone.h.

Referenced by addPathOrAlgorithm(), hasPathOrAlgorithm(), pathsOrAlgorithms(), and TriggerObjectStandAlone().

std::vector< bool > pat::TriggerObjectStandAlone::pathLastFilterAccepted_

private

Vector alligned with 'pathNames_' of boolean indicating the usage of the trigger object An element is true, if the corresponding path succeeded and the trigger object was used in the last filter (HLT) or the corresponding algorithm succeeded as well as the corresponding condition (L1). The vector is empty for data (size 0), if the according information is not available.

Definition at line 50 of file TriggerObjectStandAlone.h.

Referenced by addPathOrAlgorithm(), hasPathOrAlgorithm(), pathsOrAlgorithms(), and TriggerObjectStandAlone().

std::vector< std::string > pat::TriggerObjectStandAlone::pathNames_

private

Vector of names of all HLT paths or L1 algorithms the trigger objects has been used in.

Definition at line 43 of file TriggerObjectStandAlone.h.

Referenced by addPathOrAlgorithm(), checkIfPathsAreUnpacked(), hasPathOrAlgorithm(), packPathNames(), pathsOrAlgorithms(), TriggerObjectStandAlone(), and unpackPathNames().