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

bool	coll (const std::string &collName) const override
	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...

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

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

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...

	~TriggerObjectStandAlone () override
	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

	~TriggerObject () override
	Destructor. More...

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

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

LeafCandidate *	clone () const override
	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)

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

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

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

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

double	energy () const final
	energy More...

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

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

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

void	fillVertexCovariance (CovarianceMatrix &v) const override
	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...

bool	hasMasterClone () const override

bool	hasMasterClonePtr () const override

bool	isCaloMuon () const override

bool	isConvertedPhoton () const override

bool	isElectron () const override

bool	isGlobalMuon () const override

bool	isJet () const override

bool	isMuon () const override

bool	isPhoton () const override

bool	isStandAloneMuon () const override

bool	isTrackerMuon () const override

	LeafCandidate ()

	LeafCandidate (const Candidate &c)

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

	LeafCandidate (LeafCandidate &rh)

	LeafCandidate (LeafCandidate &&)=default

	LeafCandidate (LeafCandidate const &)=default

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

double	mass () const final
	mass More...

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

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

const CandidateBaseRef &	masterClone () const override

const CandidatePtr &	masterClonePtr () const override

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

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

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

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

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...

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

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

size_t	numberOfSourceCandidatePtrs () const override

LeafCandidate &	operator= (LeafCandidate &&)=default

LeafCandidate &	operator= (LeafCandidate const &)=default

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

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

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

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

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

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

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

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

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

double	rapidity () const final
	rapidity More...

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

void	setLongLived () final

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

void	setMassConstraint () final

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

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

void	setPdgId (int pdgId) final

void	setPz (double pz) final

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

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

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

CandidatePtr	sourceCandidatePtr (size_type i) const override

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

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

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

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

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

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

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

double	vertexNdof () const override

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

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

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

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

double	y () const final
	rapidity More...

	~LeafCandidate () override
	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 23 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 32 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 41 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 50 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 59 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 67 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

pat::TriggerObjectStandAlone::~TriggerObjectStandAlone ( )

inlineoverride

Destructor.

Definition at line 114 of file TriggerObjectStandAlone.h.

114 {};

Member Function Documentation

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

inline

Adds a new L1 algorithm name.

Definition at line 131 of file TriggerObjectStandAlone.h.

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

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

inline

Adds a new L1 condition name.

Definition at line 123 of file TriggerObjectStandAlone.h.

123 { addFilterOrCondition(conditionName); };

pat::TriggerObjectStandAlone::addFilterOrCondition

void addFilterOrCondition(const std::string &name)

Adds a new HLT filter label or L1 condition name.

Definition: TriggerObjectStandAlone.h:67

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

inline

Adds a new HLT filter label.

Definition at line 121 of file TriggerObjectStandAlone.h.

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

121 { addFilterOrCondition(filterLabel); };

HLT_2018_cff.filterLabel

filterLabel

Definition: HLT_2018_cff.py:79199

pat::TriggerObjectStandAlone::addFilterOrCondition

void addFilterOrCondition(const std::string &name)

Adds a new HLT filter label or L1 condition name.

Definition: TriggerObjectStandAlone.h:67

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

inlineprivate

Adds a new HLT filter label or L1 condition name.

Definition at line 67 of file TriggerObjectStandAlone.h.

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

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

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

inline

Adds a new HLT path name.

Definition at line 125 of file TriggerObjectStandAlone.h.

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

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

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

private

Adds a new HLT path or L1 algorithm name.

Definition at line 128 of file TriggerObjectStandAlone.cc.

References checkIfPathsAreUnpacked(), hasPathOrAlgorithm(), Skims_PA_cff::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 185 of file TriggerObjectStandAlone.h.

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

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

inline

Gets all L1 algorithm names.

Definition at line 143 of file TriggerObjectStandAlone.h.

                                                                             {
       return pathsOrAlgorithms(algoCondAccepted, false);
     };

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

Definition at line 395 of file TriggerObjectStandAlone.cc.

References edmTracerLogToSimpleConfig::allModules, edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), mps_fire::i, edm::ParameterSet::insert(), visualization-live-secondInstance_cfg::m, dqmiodumpmetadata::n, edm::EventBase::parameterSet(), muonDTDigis_cfi::pset, runTheMatrix::ret, BeamBkgSkim_cff::saveTags, and L1TEGammaOffline_cfi::triggerNames.

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;
   }
 
   const 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)) {
             const 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 nullptr;
 }

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 268 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 259 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;
 }

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

inlineoverridevirtual

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

Reimplemented from pat::TriggerObject.

Definition at line 189 of file TriggerObjectStandAlone.h.

189 { return hasCollection(collName); };

pat::TriggerObjectStandAlone::hasCollection

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

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

Definition: TriggerObjectStandAlone.cc:235

trigObjTnPSource_cfi.collName

collName

Definition: trigObjTnPSource_cfi.py:65

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

inline

Calls 'hasConditionName(...)'.

Definition at line 177 of file TriggerObjectStandAlone.h.

177 { 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:151

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

inline

Gets all L1 condition names.

Definition at line 137 of file TriggerObjectStandAlone.h.

137 { return filtersOrConditions(); };

pat::TriggerObjectStandAlone::filtersOrConditions

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

Gets all HLT filter labels or L1 condition names.

Definition: TriggerObjectStandAlone.h:74

TriggerObjectStandAlone pat::TriggerObjectStandAlone::copy ( ) const

inline

Methods.

Definition at line 118 of file TriggerObjectStandAlone.h.

118 { 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 175 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().

175 { return hasFilterLabel(filterLabel); };

HLT_2018_cff.filterLabel

filterLabel

Definition: HLT_2018_cff.py:79199

pat::TriggerObjectStandAlone::hasFilterLabel

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

Checks, if a certain HLT filter label is assigned.

Definition: TriggerObjectStandAlone.h:149

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

inline

Gets all HLT filter labels.

Definition at line 135 of file TriggerObjectStandAlone.h.

135 { return filtersOrConditions(); };

pat::TriggerObjectStandAlone::filtersOrConditions

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

Gets all HLT filter labels or L1 condition names.

Definition: TriggerObjectStandAlone.h:74

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

inlineprivate

Gets all HLT filter labels or L1 condition names.

Definition at line 74 of file TriggerObjectStandAlone.h.

References AlCaHLTBitMon_QueryRunRegistry::string.

                                                             {
       checkIfFiltersAreUnpacked();
       return filterLabels_;
     };

bool pat::TriggerObjectStandAlone::hasAlgoCondAccepted ( ) const

inline

Definition at line 167 of file TriggerObjectStandAlone.h.

167 { return hasLastFilter(); };

pat::TriggerObjectStandAlone::hasLastFilter

bool hasLastFilter() const

Check, if the usage indicator vectors have been filled.

Definition: TriggerObjectStandAlone.h:85

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 159 of file TriggerObjectStandAlone.h.

References trigObjTnPSource_cfi::collName, and AlCaHLTBitMon_QueryRunRegistry::string.

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

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

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 79 of file TriggerObjectStandAlone.cc.

References runEdmFileComparison::failed, cms::dd::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

overridevirtual

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

Reimplemented from pat::TriggerObject.

Definition at line 235 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);
 }

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

inlineoverridevirtual

Reimplemented from pat::TriggerObject.

Definition at line 164 of file TriggerObjectStandAlone.h.

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

Referenced by hasCollection().

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

pat::TriggerObjectStandAlone::hasCollection

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

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

Definition: TriggerObjectStandAlone.cc:235

edm::InputTag::encode

std::string encode() const

Definition: InputTag.cc:159

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

inline

Checks, if a certain L1 condition name is assigned.

Definition at line 151 of file TriggerObjectStandAlone.h.

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

151 { 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:183

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

inline

Checks, if a certain HLT filter label is assigned.

Definition at line 149 of file TriggerObjectStandAlone.h.

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

149 { return hasFilterOrCondition(filterLabel); };

HLT_2018_cff.filterLabel

filterLabel

Definition: HLT_2018_cff.py:79199

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:183

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 183 of file TriggerObjectStandAlone.cc.

References checkIfFiltersAreUnpacked(), filterLabels_, spr::find(), hasAnyName(), Skims_PA_cff::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 88 of file TriggerObjectStandAlone.h.

Referenced by hasPathOrAlgorithm(), and pathsOrAlgorithms().

                              {
       return (!pathL3FilterAccepted_.empty() && pathL3FilterAccepted_.size() == pathNames_.size());
     };

bool pat::TriggerObjectStandAlone::hasLastFilter ( ) const

inlineprivate

Check, if the usage indicator vectors have been filled.

Definition at line 85 of file TriggerObjectStandAlone.h.

Referenced by hasPathOrAlgorithm(), and pathsOrAlgorithms().

                                {
       return (!pathLastFilterAccepted_.empty() && pathLastFilterAccepted_.size() == pathNames_.size());
     };

bool pat::TriggerObjectStandAlone::hasPathL3FilterAccepted ( ) const

inline

Definition at line 168 of file TriggerObjectStandAlone.h.

168 { return hasL3Filter(); };

pat::TriggerObjectStandAlone::hasL3Filter

bool hasL3Filter() const

Definition: TriggerObjectStandAlone.h:88

bool pat::TriggerObjectStandAlone::hasPathLastFilterAccepted ( ) const

inline

Checks, if the usage indicator vector has been filled.

Definition at line 166 of file TriggerObjectStandAlone.h.

166 { return hasLastFilter(); };

pat::TriggerObjectStandAlone::hasLastFilter

bool hasLastFilter() const

Check, if the usage indicator vectors have been filled.

Definition: TriggerObjectStandAlone.h:85

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 153 of file TriggerObjectStandAlone.h.

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

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

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 194 of file TriggerObjectStandAlone.cc.

References checkIfPathsAreUnpacked(), spr::find(), hasAnyName(), hasL3Filter(), hasLastFilter(), match(), Skims_PA_cff::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 327 of file TriggerObjectStandAlone.cc.

References Exception, filterLabelIndices_, filterLabels_, mps_fire::i, bTagCombinedSVVariables_cff::indices, match(), eostools::move(), and dqmiodumpmetadata::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 380 of file TriggerObjectStandAlone.cc.

References CMS_THREAD_SAFE, 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 278 of file TriggerObjectStandAlone.cc.

References reco::Candidate::end(), Exception, mps_fire::i, pat::TriggerObject::id(), bTagCombinedSVVariables_cff::indices, dqmiodumpmetadata::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 179 of file TriggerObjectStandAlone.h.

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

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

inline

Gets all HLT path names.

Definition at line 139 of file TriggerObjectStandAlone.h.

                                                                                                                 {
       return pathsOrAlgorithms(pathLastFilterAccepted, pathL3FilterAccepted);
     };

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

private

Gets all HLT path or L1 algorithm names.

Definition at line 158 of file TriggerObjectStandAlone.cc.

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

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 194 of file TriggerObjectStandAlone.h.

References SummaryClient_cfi::labels, names, slimmedPatTrigger_cfi::packFilterLabels, slimmedPatTrigger_cfi::packP4, and triggerObjects_cff::unpackFilterLabels.

194 { return psetId_; }

pat::TriggerObjectStandAlone::psetId_

edm::ParameterSetID psetId_

Definition: TriggerObjectStandAlone.h:55

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

inline

set the psetid of the trigger process

Definition at line 192 of file TriggerObjectStandAlone.h.

192 { psetId_ = psetId; }

pat::TriggerObjectStandAlone::psetId_

edm::ParameterSetID psetId_

Definition: TriggerObjectStandAlone.h:55

TriggerObject TriggerObjectStandAlone::triggerObject ( )

Gets the pat::TriggerObject (parent class)

Definition at line 223 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 363 of file TriggerObjectStandAlone.cc.

References Exception, filterLabelIndices_, filterLabels_, mps_fire::i, visualization-live-secondInstance_cfg::m, and dqmiodumpmetadata::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 359 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 308 of file TriggerObjectStandAlone.cc.

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

Referenced by pat::PATMuonProducer::fillHltTriggerInfo(), pat::PATMuonProducer::fillL1TriggerInfo(), and 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 39 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 38 of file TriggerObjectStandAlone.h.

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

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

private

Definition at line 43 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 53 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 49 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 42 of file TriggerObjectStandAlone.h.

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