TrigConf Namespace Reference

Forward iterator to traverse the main components of the trigger configuration. More...

Namespaces
namespace	JetWindowSize
namespace	MSGTC
	Messsage levels matching the Gaudi definition.
namespace	TrigConfCoolHLTPayloadConverters
namespace	TrigConfCoolL1PayloadConverters

Classes
class	AutoDBOpen
class	BunchGroup
class	BunchGroupCondAlg
class	BunchGroupLoader
class	BunchGroupSet
class	BunchGroupSetLoader
class	CaloInfo
class	CaloInfoLoader
	TriggerDB loader of the LVL1 calorimeter trigger configuration. More...
class	CaloJetInput
class	CaloJetInputLoader
	TriggerDB loader of the LVL1 calorimeter jet trigger configuration. More...
class	CaloSinCos
class	CaloSinCosLoader
	TriggerDB loader of the LVL1 calorimeter sin and cos configuration. More...
class	Chain
	HLT chain configuration. More...
class	ClusterThresholdValue
class	ConstIter
	Forward iterator over an iterable of type V returning an object of type T. More...
struct	counter
class	CrestLoadingException
class	CTPConfig
class	CTPConfigLoader
class	CTPFiles
class	CTPFilesLoader
	TriggerDB loader of the LVL1 LUT and CAM tables. More...
class	DataStructure
	Base class for Trigger configuration data and wrapper around underlying representation. More...
class	DBLoader
	Base class for loaders of configurations from the TriggerDB. More...
class	DeadTime
class	DeadTimeLoader
	TriggerDB loader of the LVL1 deadtime configuration. More...
class	DiffStruct
class	EtThresholdValue
class	FileWritingException
class	FolderDefinition
struct	HashMap
	Two concurrent maps to store name->hash and hash->name mappings. More...
struct	HashStore
	Store for hash maps per category. More...
class	HLTChain
	HLT chain configuration information. More...
class	HLTChainList
	list of all HLT chains in a trigger menu More...
class	HLTChainLoader
	TriggerDB loader of the HLT signatures. More...
class	HLTConfigSvc
	Service storing the HLT menu in the DetectorStore. More...
class	HLTFrame
	The HLT trigger menu,. More...
class	HLTFrameLoader
	TriggerDB loader of the HLT menu. More...
class	HLTMenu
	HLT menu configuration. More...
class	HLTMonitoring
	HLT monitoring configuration. More...
class	HLTPrescale
class	HLTPrescaleCondAlg
	Condition algorithm to provide the L1 trigger menu. More...
class	HLTPrescaleSet
	HLT chain configuration information. More...
class	HLTPrescaleSetCollection
	HLT chain configuration information. More...
class	HLTPrescaleSetCollectionLoader
class	HLTPrescaleSetLoader
class	HLTPrescalesSet
	HLT menu configuration. More...
class	HLTSequence
	HLT sequence configuration information. More...
class	HLTSequenceList
	list of HLT sequences More...
class	HLTSequenceLoader
	TriggerDB loader of the HLT signatures. More...
class	HLTSignature
	HLT signature configuration information. More...
class	HLTStreamTag
	HLT stream configuration information. More...
class	HLTTEUtils
	HLTUtils is renamed in r22 to HLTTEUtils. More...
class	HLTTriggerElement
	HLT trigger element configuration information. More...
class	HLTTriggerType
	HLT trigger type configuration information. More...
class	HLTUtils
class	IBunchGroupLoader
class	IBunchGroupSetLoader
class	ICaloInfoLoader
class	ICaloJetInputLoader
class	ICaloSinCosLoader
class	ICTPConfigLoader
class	ICTPFilesLoader
class	IDeadTimeLoader
class	IHLTConfigSvc
	Athena interface for all services that provide HLT menu configuration information. More...
class	IHLTFrameLoader
class	IHLTPrescaleSetCollectionLoader
class	IHLTPrescaleSetLoader
class	IIHLTConfigSvc
	Interface for all services/tools that provide HLT menu configuration information. More...
class	IILVL1ConfigSvc
	Interface for all services/tools that provide LVL1 menu configuration information. More...
class	IJobOptionsSvc
	Trigger-specific JobOptionsSvc interface. More...
class	IJobOptionTableLoader
class	IKeyWriterTool
class	IL1TopoMenuLoader
class	ILoader
	Interface class for loaders. More...
class	ILutCamLoader
class	ILVL1ConfigSvc
	Athena interface for all services that provide LVL1 menu configuration information. More...
class	IMasterTableLoader
	Interface for loaders of the LVL1 trigger configuration. More...
class	IMenuLoader
class	IMuctpiLoader
class	IMuonThresholdSetLoader
class	IOException
class	IPrescaledClockLoader
class	IPrescaleSetLoader
class	IPrioritySetLoader
class	IRandomLoader
class	ISequenceContentTableLoader
	Interface for loaders of the HLT sequences. More...
class	ISignatureContentTableLoader
	Interface for loaders of the HLT signatures. More...
class	IsolationLegacy
class	IsolationParam
class	IStorageMgr
	Interface for the StorageMgr (TriggerDB) and XMLStorageMgr (XML) classes. More...
class	IThresholdConfigLoader
class	IThresholdMonitorLoader
class	ITrigConfigSvc
	Athena interface for all service that provide L1Topo, LVL1, and HLT menu configuration information. More...
class	ITrigConfigTool
	Interface for dual-use tools that provide trigger configuration information. More...
class	ITriggerThresholdLoader
class	ITriggerThresholdValueLoader
class	ITriggerTypeLoader
class	JetThresholdValue
class	JobOption
	hold a single job option (parameter and value) More...
class	JobOptionsSvc
	JobOptionsSvc for the HLT. More...
class	JobOptionTable
	table to hold the complete list of JobOption entries for a single configuration, from which the JobOptionsCatalogue is built. More...
class	JobOptionTableLoader
	TriggerDB loader of the HLT job options. More...
class	JsonFileLoader
	Loader of trigger configurations from Json files. More...
class	JsonFileWriterHLT
	Loader of trigger configurations from Json files. More...
class	JsonFileWriterL1
	Loader of trigger configurations from Json files. More...
class	JsonParsingException
class	KeyWriterTool
class	L1Board
	a TriggerLine entry describes the location of a threshold multiplicity on a cable (connector) More...
class	L1BunchGroup
	Bunchgroup and BunchgroupSet representation. More...
class	L1BunchGroupSet
	L1 board configuration. More...
class	L1Connector
	L1 connectors configuration. More...
class	L1CTP
	a TriggerLine entry describes the location of a threshold multiplicity on a cable (connector) More...
class	L1CTPFiles
	L1 menu configuration. More...
class	L1DataBaseclass
class	L1DataDef
class	L1Item
	L1 threshold configuration. More...
class	L1Menu
	L1 menu configuration. More...
class	L1PrescaleCondAlg
	Condition algorithm to provide the L1 trigger menu. More...
class	L1PrescalesSet
	L1 menu configuration. More...
class	L1PSNumber
class	L1Threshold
	Standard L1 threshold configuration. More...
class	L1Threshold_Calo
class	L1Threshold_cTAU
class	L1Threshold_eEM
class	L1Threshold_EM
class	L1Threshold_eTAU
class	L1Threshold_gJ
class	L1Threshold_gLJ
class	L1Threshold_gTE
class	L1Threshold_gXE
class	L1Threshold_internal
class	L1Threshold_jEM
class	L1Threshold_JET
class	L1Threshold_jJ
class	L1Threshold_jLJ
class	L1Threshold_jTAU
class	L1Threshold_jTE
class	L1Threshold_jXE
class	L1Threshold_MU
class	L1Threshold_NIM
class	L1Threshold_TAU
class	L1Threshold_TE
class	L1Threshold_XE
class	L1Threshold_XS
class	L1Threshold_ZB
class	L1Threshold_ZBTopo
class	L1ThrExtraInfo
class	L1ThrExtraInfo_cTAU
class	L1ThrExtraInfo_eEM
class	L1ThrExtraInfo_EMTAULegacy
class	L1ThrExtraInfo_eTAU
class	L1ThrExtraInfo_gJ
class	L1ThrExtraInfo_gLJ
class	L1ThrExtraInfo_gTE
class	L1ThrExtraInfo_gXE
class	L1ThrExtraInfo_jEM
class	L1ThrExtraInfo_JETLegacy
class	L1ThrExtraInfo_jJ
class	L1ThrExtraInfo_jLJ
class	L1ThrExtraInfo_jTAU
class	L1ThrExtraInfo_jTE
class	L1ThrExtraInfo_jXE
class	L1ThrExtraInfo_MU
class	L1ThrExtraInfo_XSLegacy
class	L1ThrExtraInfoBase
	L1 extra information for certain threshold types. More...
class	L1TopoAlgorithm
	L1Topo algorithm configuration. More...
class	L1TopoMenuLoader
	TriggerDB loader of the HLT menu. More...
class	L1TopoOutput
	L1Topo output line configuration. More...
class	Logic
	Class to hold the logic structure representing a logical expression and evaluate it for a given state. More...
class	LogicAND
class	LogicExpression
class	LogicLeaf
class	LogicOPS
class	LogicOR
class	LogicParsingException
class	LutCam
class	LutCamLoader
class	LVL1Config
class	LVL1ConfigSvc
	Service storing the LVL1 menu in the DetectorStore. More...
class	MasterTableLoader
	TriggerDB loader of the LVL1 trigger configuration. More...
class	MCKLoader
class	Menu
class	MenuLoader
	TriggerDB loader of the LVL1 trigger menu configuration. More...
struct	MenuPtrWrapper
	Small utility class to wrap a pointer to a const xAOD::TriggerMenu. More...
class	METSigParam
struct	MinTOBPt
class	MsgStreamTC
	MsgStreamTC class to be used in TrigConf equivalent to Gaudi's MsgStream. More...
class	Muctpi
class	MuctpiLoader
class	MuonThresholdSet
class	MuonThresholdSetLoader
	TriggerDB loader of the LVL1 muon h/w configuration for online use. More...
class	MuonThresholdValue
struct	name
struct	name_hash
class	NimThresholdValue
class	NoBGSKException
class	NoHLTPSKException
class	NoKeyException
class	NoL1PSKException
class	NoQueryException
class	NoSMKException
class	ParsingException
class	PIT
class	PrescaledClock
class	PrescaledClockLoader
class	PrescaleSet
class	PrescaleSetLoader
class	PrioritySet
class	PrioritySetLoader
class	QueryDefinition
class	QueryException
class	Random
class	RandomLoader
class	ReplicaSorter
class	Selection
struct	seq_hash_id
struct	seq_name_hash
class	SessionMgr
	Manager of the database session. More...
class	StorageMgr
	Database Storage Manager, controls the database session and the different loader classes for DB access. More...
class	StorageMgrBase
struct	tag_ctpid
struct	tag_name_hash
class	ThresholdConfig
class	ThresholdConfigLoader
	TriggerDB loader of the LVL1 trigger threshold configuration. More...
class	ThresholdMonitor
class	ThresholdMonitorLoader
class	TIP
class	TrigConfCoolFolderSpec
	Definition of the COOL folder structure for the trigger configuration data. More...
class	TrigConfCoolWriter
	Reading/Writing of trigger configuration data from/to COOL. More...
class	TrigConfData
class	TrigConfMessaging
	Class to provide easy access to TrigConf::MsgStream for TrigConf classes. More...
class	TrigDBConnectionConfig
class	TrigDBCTPFilesLoader
	Loader of trigger configurations from Json files. More...
class	TrigDBHLTPrescalesSetLoader
	Loader of trigger configurations from Json files. More...
class	TrigDBJobOptionsLoader
	Loader of trigger configurations from Json files. More...
class	TrigDBL1BunchGroupSetLoader
	Loader of trigger configurations from Json files. More...
class	TrigDBL1PrescalesSetLoader
	Loader of trigger configurations from Json files. More...
class	TrigDBLoader
	Loader of trigger configurations from the Trigger database. More...
class	TrigDBMenuLoader
	Loader of trigger menu configurations from the database. More...
class	TrigDBMonitoringLoader
	Loader of trigger menu configurations from the database. More...
class	TriggerItem
class	TriggerItemNode
class	TriggerLine
	a TriggerLine entry describes the location of a threshold multiplicity on a cable (connector) More...
struct	TriggerMenuJsonPtrWrapper
	Small utility class to wrap a pointer to a const xAOD::TriggerMenuJson. More...
class	TriggerThreshold
class	TriggerThresholdLoader
	TriggerDB loader of the LVL1 trigger thresholds. More...
class	TriggerThresholdValue
class	TriggerThresholdValueLoader
class	ValidityRange
class	ValueWithEtaDependence
	class to implement a L1 threshold cut that varies with eta More...
class	xAODConfigSvc
	Trigger configuration service used when reading an xAOD file. More...
class	xAODConfigTool
	Trigger configuration metadata tool for xAOD analysis. More...
class	xAODMenuReader
	Algorithm for testing the xAOD menu reading in Athena. More...
class	xAODMenuWriter
	Algorithm used to write the light-weight xAOD configuration in the Run3 JSON format. More...
class	XEFlavour
class	XsThresholdValue

Typedefs
typedef boost::multi_index::multi_index_container< HLTChain *, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::identity< HLTChain > >, boost::multi_index::ordered_unique< boost::multi_index::tag< counter >, boost::multi_index::composite_key< HLTChain *, boost::multi_index::const_mem_fun< HLTChain, int,&HLTChain::chain_counter >, boost::multi_index::const_mem_fun< HLTChain, HLTLevel,&HLTChain::level_enum > > >, boost::multi_index::ordered_unique< boost::multi_index::tag< name >, boost::multi_index::const_mem_fun< HLTChain, const std::string &, &HLTChain::chain_name > >, boost::multi_index::hashed_unique< boost::multi_index::tag< name_hash >, boost::multi_index::const_mem_fun< HLTChain, const std::string &, &HLTChain::chain_name > >, boost::multi_index::random_access<> > >	HLTChainContainer
typedef boost::multi_index::multi_index_container< HLTSequence *, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::identity< HLTSequence > >, boost::multi_index::ordered_unique< boost::multi_index::tag< seq_hash_id >, boost::multi_index::const_mem_fun< HLTSequence, unsigned int, &HLTSequence::hashId > >, boost::multi_index::hashed_unique< boost::multi_index::tag< seq_name_hash >, boost::multi_index::const_mem_fun< TrigConfData, const std::string &, &TrigConfData::name > > > >	HLTSequenceContainer
typedef uint32_t	HLTHash
typedef boost::multi_index::multi_index_container< TriggerItem *, boost::multi_index::indexed_by< boost::multi_index::random_access<>, boost::multi_index::ordered_unique< boost::multi_index::identity< TriggerItem > >, boost::multi_index::ordered_unique< boost::multi_index::tag< tag_ctpid >, boost::multi_index::const_mem_fun< TriggerItem, int, &TriggerItem::ctpId > >, boost::multi_index::hashed_unique< boost::multi_index::tag< tag_name_hash >, boost::multi_index::const_mem_fun< TrigConfData, const std::string &, &TrigConfData::name > > > >	ItemContainer
typedef ItemContainer::index< tag_ctpid >::type	item_by_ctpid_t
typedef item_by_ctpid_t::iterator	item_by_ctpid_iterator
typedef ItemContainer::index< tag_name_hash >::type	item_by_name_t
typedef ItemContainer::index< tag_name_hash >::type::iterator	item_by_name_iterator
typedef std::pair< unsigned int, unsigned int >	RunRange
typedef std::vector< RunRange >	RunRangeVec
typedef CTPConfigLoader	CTPConfigOnlineLoader
typedef std::vector< std::shared_ptr< LogicExpression > >	LogicV_t

Enumerations
enum	HLTLevel { L2 =0 , EF , HLT }

Functions
MsgStreamTC &	endmsgtc (MsgStreamTC &s)
	End of message.
unsigned int	energyInCounts (unsigned int energyMeV, unsigned int energyResolutionMeV)
	helper funtion to translate energies into counts
std::ostream &	operator<< (std::ostream &os, const TrigConf::IsolationLegacy &iso)
std::ostream &	operator<< (std::ostream &os, const TrigConf::L1ThrExtraInfo_eEM::WorkingPoints_eEM &iso)
std::ostream &	operator<< (std::ostream &os, const TrigConf::L1ThrExtraInfo_jEM::WorkingPoints_jEM &iso)
std::ostream &	operator<< (std::ostream &os, const TrigConf::L1ThrExtraInfo_eTAU::WorkingPoints_eTAU &iso)
std::ostream &	operator<< (std::ostream &os, const TrigConf::L1ThrExtraInfo_jTAU::WorkingPoints_jTAU &iso)
std::ostream &	operator<< (std::ostream &os, const TrigConf::L1ThrExtraInfo_cTAU::WorkingPoints_cTAU &iso)
std::vector< std::string >	parse (std::string names)
void	recursivelyFindOutputTEs (const std::string &tename, const TrigConf::HLTSequenceList &sequenceList, std::set< std::string > &tes, int level, const std::set< std::string > *veto=0)
void	recursivelyFindOutputTEsWithLevelFromSequence (const std::string &tename, const TrigConf::HLTSequenceList &sequenceList, std::set< std::string > &tes, int level)
std::ostream &	operator<< (std::ostream &, const HLTChain &)
std::ostream &	operator<< (std::ostream &o, const TrigConf::HLTChainList &c)
std::ostream &	operator<< (std::ostream &, const HLTFrame &)
HLTLevel	str2lvl (const std::string &level)
std::string	lvl2str (HLTLevel level)
std::ostream &	operator<< (std::ostream &, const TrigConf::HLTPrescale &)
std::ostream &	operator<< (std::ostream &, const TrigConf::HLTPrescaleSet &)
std::ostream &	operator<< (std::ostream &, const TrigConf::HLTPrescaleSetCollection &)
std::ostream &	operator<< (std::ostream &, const HLTSequence &)
std::ostream &	operator<< (std::ostream &, const HLTSequenceList &)
std::ostream &	operator<< (std::ostream &, const HLTSignature &)
std::ostream &	operator<< (std::ostream &, const TrigConf::HLTStreamTag &)
std::ostream &	operator<< (std::ostream &, const HLTTriggerElement &)
std::ostream &	operator<< (std::ostream &, const HLTTriggerType &)
uint32_t	doTruncatedHash (const std::stringstream &ss)
uint32_t	truncatedHash (const DataStructure &dataStructure)
	Function to compute a truncated MD5 hash for a JSON file.
uint32_t	truncatedHash (const TrigConf::L1Menu &L1DataStructure, const TrigConf::HLTMenu &HLTDataStructure)
	Function to compute a truncated MD5 hash for a JSON file.
bool	isCrestConnection (const std::string &db_connection_string, std::string &crest_server, std::string &crest_api, std::string &dbname)
	Function to interpret the trigger connection string for CREST connections Format of the connections string:
void	blobToPtree (const coral::Blob &blob, boost::property_tree::ptree &pt)
void	stringToPtree (const std::string &json_string, boost::property_tree::ptree &pt)
void	writeRawFile (const coral::Blob &data, const std::string &outFileName)
	write coral data blob to file
void	writeRawFile (const std::string &data, const std::string &outFileName)
	write string into file
std::vector< std::string >	split (const std::string &line, const std::string &del=" ")
void	strip (std::string &str)
void	replaceTabs (std::string &str)
void	toLower (std::string &)
uint32_t	bin2uint (const std::string &binary)
std::string	uint2bin (uint32_t uinteger, uint16_t width)
TrigConf::TriggerItemNode *	parse (const std::string &logic, const std::vector< std::string > &conditions, const std::vector< TrigConf::TriggerThreshold * > &thrs)
std::string::size_type	findClosingBracket (std::string::size_type pos, const std::string &logic)
TrigConf::TriggerItemNode *	buildObjNode (uint32_t condIdx, const std::vector< std::string > &conditions, const std::vector< TrigConf::TriggerThreshold * > &thrs)
std::string	insertParenthesis (const std::string &givenlogic)
std::ostream &	operator<< (std::ostream &, const TrigConfData &)
std::ostream &	operator<< (std::ostream &, const TrigConf::TriggerItem &)
std::ostream &	operator<< (std::ostream &o, const TrigConf::TriggerItemNode &node)
void	fillQuery (coral::IQuery *q, coral::AttributeList &attList)
std::string	rmtilde (const std::string &input)
void	printTable (const coral::ITable &teTable)
StatusCode	prepareTriggerMenu (const xAOD::TriggerMenu *menu, CTPConfig &ctpConfig, HLTChainList &chainList, HLTSequenceList &sequenceList, BunchGroupSet &bgSet, MsgStream &msg)
	In order to avoid duplicating code between how the dual-use and the Athena-only code translates the xAOD metadata into the transient trigger configuration information, this function is used by both to achieve this.
template<typename T>
std::vector< T >	ToVector (const TrigConf::DataStructure &ds, const std::string &child)
	Helper function ptree key->[] to std::vector<T>
template<typename T>
std::vector< std::vector< T > >	ToVectorVector (const TrigConf::DataStructure &ds, const std::string &child)
	Helper function ptree key->[[]] to std::vector<std::vector<T>>
StatusCode	prepareTriggerMenu (const HLTMenu &loadedHlt, const L1Menu &loadedL1, const HLTPrescalesSet &loadedHltps, const L1PrescalesSet &loadedL1ps, const L1BunchGroupSet &loadedBgSet, CTPConfig &ctpConfig, HLTChainList &chainList, HLTSequenceList &sequenceList, BunchGroupSet &bgSet, MsgStream &msg)
	Load JSON derived data into legacy structures to maintain compatiblity with existing code.
bool	xAODKeysMatch (const xAOD::TrigConfKeys *keys, const xAOD::TriggerMenu *menu)
	Since this is used in a couple of places, it seemed to make sense to put this simple code into a central place.
bool	xAODKeysMatch (const xAOD::TriggerMenu *menuA, const xAOD::TriggerMenu *menuB)
	Helper function checking if the DB keys match on two objects.

Detailed Description

Forward iterator to traverse the main components of the trigger configuration.

class PrescaleSet contains prescales of a Level 1 partition

Loader class for HLT monitoring configuration from the Trigger DB.

Write Json file from L1Menu object To validate correct loading of the L1 menu.

Write Json file from HLTMenu object To validate correct loading of the HLT menu.

helper class to store a query

Namespace holding all the trigger configuration code.

Base class for Trigger configuration data and wrapper around underlying representation.

In run 2 the CTP uses a new prescaling mechanism: for each item a 24-bit pseudo-random number generator is used. If the resulting (thrown) number is

Typedef Documentation

CTPConfigOnlineLoader

typedef CTPConfigLoader TrigConf::CTPConfigOnlineLoader

Definition at line 25 of file CTPConfigOnlineLoader.h.

HLTChainContainer

typedef boost::multi_index::multi_index_container<HLTChain*, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::identity<HLTChain> >, boost::multi_index::ordered_unique< boost::multi_index::tag<counter>, boost::multi_index::composite_key< HLTChain*, boost::multi_index::const_mem_fun<HLTChain,int,&HLTChain::chain_counter>, boost::multi_index::const_mem_fun<HLTChain,HLTLevel,&HLTChain::level_enum> > >, boost::multi_index::ordered_unique< boost::multi_index::tag<name>, boost::multi_index::const_mem_fun<HLTChain, const std::string&, &HLTChain::chain_name> >, boost::multi_index::hashed_unique< boost::multi_index::tag<name_hash>, boost::multi_index::const_mem_fun<HLTChain,const std::string&, &HLTChain::chain_name> >, boost::multi_index::random_access<> > > TrigConf::HLTChainContainer

Definition at line 52 of file HLTChainList.h.

HLTHash

typedef uint32_t TrigConf::HLTHash

Definition at line 19 of file TrigConfHLTUtils/TrigConfHLTUtils/HLTUtils.h.

HLTSequenceContainer

typedef boost::multi_index::multi_index_container<HLTSequence*, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::identity<HLTSequence> >, boost::multi_index::ordered_unique< boost::multi_index::tag<seq_hash_id>, boost::multi_index::const_mem_fun<HLTSequence, unsigned int, &HLTSequence::hashId> >, boost::multi_index::hashed_unique< boost::multi_index::tag<seq_name_hash>, boost::multi_index::const_mem_fun<TrigConfData, const std::string&, &TrigConfData::name> > > > TrigConf::HLTSequenceContainer

Definition at line 36 of file HLTSequenceList.h.

item_by_ctpid_iterator

typedef item_by_ctpid_t::iterator TrigConf::item_by_ctpid_iterator

Definition at line 42 of file Menu.h.

item_by_ctpid_t

typedef ItemContainer::index<tag_ctpid>::type TrigConf::item_by_ctpid_t

Definition at line 41 of file Menu.h.

item_by_name_iterator

typedef ItemContainer::index<tag_name_hash>::type::iterator TrigConf::item_by_name_iterator

Definition at line 45 of file Menu.h.

item_by_name_t

typedef ItemContainer::index<tag_name_hash>::type TrigConf::item_by_name_t

Definition at line 44 of file Menu.h.

ItemContainer

typedef boost::multi_index::multi_index_container<TriggerItem*, boost::multi_index::indexed_by< boost::multi_index::random_access<>, boost::multi_index::ordered_unique< boost::multi_index::identity<TriggerItem> >, boost::multi_index::ordered_unique< boost::multi_index::tag<tag_ctpid>, boost::multi_index::const_mem_fun<TriggerItem, int, &TriggerItem::ctpId> >, boost::multi_index::hashed_unique < boost::multi_index::tag<tag_name_hash>, boost::multi_index::const_mem_fun<TrigConfData, const std::string&, &TrigConfData::name> > > > TrigConf::ItemContainer

Definition at line 39 of file Menu.h.

LogicV_t

typedef std::vector<std::shared_ptr<LogicExpression> > TrigConf::LogicV_t

Definition at line 25 of file LogicExpression.h.

RunRange

typedef std::pair<unsigned int,unsigned int> TrigConf::RunRange

Definition at line 36 of file TrigConfCoolWriter.h.

RunRangeVec

typedef std::vector<RunRange> TrigConf::RunRangeVec

Definition at line 37 of file TrigConfCoolWriter.h.

Enumeration Type Documentation

HLTLevel

enum TrigConf::HLTLevel

Enumerator
L2
EF
HLT

Definition at line 12 of file HLTLevel.h.

{ L2=0, EF, HLT };

Function Documentation

bin2uint()

uint32_t TrigConf::bin2uint

(

const std::string &

binary

)

Definition at line 313 of file Trigger/TrigConfiguration/TrigConfL1Data/Root/HelperFunctions.cxx.

                                          {
   uint32_t value(0);
   for(char c: binary) {
      value <<= 1;
      if(c=='1') value += 1; 
   }
   return value;
}

blobToPtree()

void TrigConf::blobToPtree	(	const coral::Blob &	blob,
		boost::property_tree::ptree &	pt )

Definition at line 58 of file TrigDBHelper.cxx.

                                                                            {
   boost::iostreams::stream<boost::iostreams::array_source> stream( static_cast<const char*> ( blob.startingAddress()), 
                                                                    blob.size());
   boost::property_tree::read_json(stream, pt);
}

buildObjNode()

TrigConf::TriggerItemNode * TrigConf::buildObjNode	(	uint32_t	condIdx,
		const std::vector< std::string > &	conditions,
		const std::vector< TrigConf::TriggerThreshold * > &	thrs )

Definition at line 203 of file Trigger/TrigConfiguration/TrigConfL1Data/Root/HelperFunctions.cxx.

                                                                      {
 
   TriggerItemNode* newNode = new TriggerItemNode(TriggerItemNode::OBJ);
   
   try {
      vector<string> condDef = split(conditions[condIdx-1], ",");
 
      if(condDef.size()==1) { // internal trigger (condDef contains internal trigger name)
 
         newNode->setInternalTrigger( condDef[0] );
 
      } else { // threshold (condDef contains multiplicity, condName, and threshold name)
         // set multiplicity
         newNode->setMultiplicity(std::stoi(condDef[0]));
         // find trigger threshold in list of all thresholds and set it in the TriggerItemNode
         std::string& name = condDef[2];
         if(thrs.size()>0) {
            std::vector<TrigConf::TriggerThreshold*>::const_iterator thrIt = thrs.begin();
            for(;thrIt!=thrs.end(); ++thrIt ) {
               if((*thrIt)->name()==name) {
                  newNode->setTriggerThreshold(*thrIt);
                  break;
               }
            }
         } else {
            newNode->setThresholdName(name);
         }
      }
   }
   catch(const std::exception& e) {
      std::cout << "Exeption caught in buildObjNode for " << conditions[condIdx-1] << ": " << e.what() << std::endl;
      throw;
   }
   return newNode;
}

doTruncatedHash()

uint32_t TrigConf::doTruncatedHash

(

const std::stringstream &

ss

)

Definition at line 13 of file TrigConfMD5.cxx.

                                                      {
    MD5 md5(ss.str());
    const std::string truncated_hash_hex = md5.hex_digest().substr(0, 8); // Of 32
    std::stringstream hex_to_int;
    uint32_t truncated_hash_int = 0;
    hex_to_int << std::hex << truncated_hash_hex;
    hex_to_int >> truncated_hash_int;
    return truncated_hash_int;
  }

endmsgtc()

MsgStreamTC & TrigConf::endmsgtc ( MsgStreamTC & s )

inline

End of message.

Definition at line 113 of file Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h.

                                               {
    if (s.isActive()) s.doOutput();
    return s;
  }

energyInCounts()

unsigned int TrigConf::energyInCounts	(	unsigned int	energyMeV,
		unsigned int	energyResolutionMeV )

helper funtion to translate energies into counts

L1Threshold base class.

Parameters

energyMeV	[in] energy value in MeV
energyResolutionMeV	[in] energy resolution in MeV (energy that corresponds to one count

Returns

energy counts

The funtion throws a runtime error if the energy value is not a multiple of the resolution

Definition at line 18 of file L1ThresholdBase.cxx.

{
   if ( energyMeV % energyResolutionMeV != 0 ) {
      throw std::runtime_error("Energy " + std::to_string(energyMeV) + " MeV is not a multiple of the energy resolution " + std::to_string(energyResolutionMeV));
   }
   return energyMeV / energyResolutionMeV;
}

fillQuery()

void TrigConf::fillQuery	(	coral::IQuery *	q,
		coral::AttributeList &	attList )

Definition at line 13 of file DBHelper.cxx.

                                                               {
   q->defineOutput(attList);
   for(coral::AttributeList::iterator attr=attList.begin(); attr!=attList.end(); ++attr)
      q->addToOutputList(attr->specification().name());
}

findClosingBracket()

std::string::size_type TrigConf::findClosingBracket	(	std::string::size_type	pos,
		const std::string &	logic )

Definition at line 270 of file Trigger/TrigConfiguration/TrigConfL1Data/Root/HelperFunctions.cxx.

                                                     {
 
   pos++;
   uint32_t openBrackets = 1;
   std::string::size_type last = logic.size();
   while(openBrackets>0 && pos!=last) {
      if(logic[pos]==')') openBrackets--;
      if(logic[pos]=='(') openBrackets++;
      pos++;
   }
   if (openBrackets>0) {
      std::string errMsg = "No matching closing bracket in '";
      errMsg += logic;
      errMsg += "'";
      throw std::logic_error(errMsg);
   }
   return pos-1;
}

insertParenthesis()

std::string TrigConf::insertParenthesis

(

const std::string &

givenlogic

)

Definition at line 291 of file Trigger/TrigConfiguration/TrigConfL1Data/Root/HelperFunctions.cxx.

                                                       {
   std::string logicWithPars(givenlogic);
   size_t last = givenlogic.size()-1;   
   bool leadingAnd(false);
   for(size_t pos = 0;pos<last;pos++) {
      char c = logicWithPars[pos];
      if(c=='(') { pos=findClosingBracket(pos,givenlogic); continue; }
      if(c=='&') leadingAnd=true;
      if(c=='|') {
         if(leadingAnd) {
            logicWithPars.insert(pos,")");
            logicWithPars.insert(0,"(");
         }
         break;
      }
   }
   return logicWithPars;
}

isCrestConnection()

bool TrigConf::isCrestConnection	(	const std::string &	db_connection_string,
		std::string &	crest_server,
		std::string &	crest_api,
		std::string &	dbname )

Function to interpret the trigger connection string for CREST connections Format of the connections string:

• TRIGGERDB for connections using CORAL
• https://crest.cern.ch/api-v5.0//CONF_DATA_RUN3 for CREST connections

Parameters

db_connection_string	The database connection string
crest_server	The server address (including protocol such as https://)
crest_api	The API version
dbname	The database name

Returns

true if the connection is a CREST connection

Definition at line 9 of file TrigConfSvcHelper.cxx.

                                                                                         {
   // Implementation of the function
   if(!db_connection_string.starts_with("http")) {
      return false;
   }
 
   std::string url = db_connection_string;
   std::size_t protocol_end = url.find("://");
   std::string protocol;
 
   // --- 1. Extract protocol ---
   if (protocol_end != std::string::npos) {
      protocol = url.substr(0, protocol_end);
   } else {
      protocol = ""; // no protocol given
      protocol_end = -3; // so that host_start = 0 below
   }
 
   // --- 2. Extract host ---
   std::size_t host_start = protocol_end + 3;
   std::size_t host_end = url.find('/', host_start);
   std::string host = (host_end == std::string::npos) ? \
      url.substr(host_start) : url.substr(host_start, host_end - host_start);
   // server is protocol + host
   crest_server = std::format("{}://{}", protocol, host);
 
   // --- 3. Extract path ---
   std::string path = (host_end != std::string::npos) ? url.substr(host_end) : "";
 
   // --- 4. Remove trailing slashes ---
   while (!path.empty() && path.back() == '/')
      path.pop_back();
 
   // --- 5. Split path into non-empty parts ---
   std::vector<std::string> path_parts;
   std::stringstream ss(path);
   std::string segment;
 
   while (std::getline(ss, segment, '/')) {
      if (!segment.empty()) {
         path_parts.push_back(segment);
      }
   }
   if(path_parts.empty()) {
      throw std::runtime_error("TrigConfJobOptionsSvc: crest connection '" + db_connection_string + "' is missing the database name.");
   }
   crest_api = "";
   dbname = "";
   if(path_parts.size()==1) {
      dbname = path_parts[0];
   } else if(path_parts.size()==2) {
      crest_api = path_parts[0];
      dbname = path_parts[1];
   }
   return true;
}

lvl2str()

std::string TrigConf::lvl2str ( HLTLevel level )

inline

Definition at line 19 of file HLTLevel.h.

                                            {
      return level==L2 ? "L2" :
         (level==EF ? "EF" : "HLT");
   }

operator<<() [1/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const HLTChain &	c )

Definition at line 418 of file TrigConfHLTData/Root/HLTChain.cxx.

                                                               {
   int dp = o.precision();
   o << "- -- HLTChain printout ------------------------------------- " << endl;
   o << "- --   name='"               << c.name()
     << "' [v "                    << c.m_chain_version << "]"
     << " | counter: "             << c.m_chain_counter
     << " | level: "               << c.m_level
     << " | lower_chain_name: "    << c.m_lower_chain_name
     << " | lower_chain_counter: " << c.m_lower_chain_counter;
   if (c.m_level == "HLT")  o << " | EB_after_step:  " << c.m_EB_after_step;
   
   o.precision(3);
   o.setf(std::ios::fixed, std::ios::floatfield); 
   o << " | prescale: "            << c.prescale()
     << " | pass_through: "        << c.pass_through();
   o << " | rerun: " << c.prescales().getRerunPrescales().size() << " [ ";
   for(TrigConf::HLTPrescale::value_type rrps : c.prescales().getRerunPrescales()) o << rrps.first << ":" << rrps.second << " ";
   o << "]" << endl;
   o << endl;
 
   set<std::string>::const_iterator group = c.m_groups.begin();
   o << "- -- Chain groups : " << c.m_groups.size() << "  [ ";
   for (; group   != c.m_groups.end();   ++group)   o << "'" << *group << "' ";
   o << "]" << std::endl;
 
   vector<TrigConf::HLTTriggerType*>::const_iterator triggerType = c.m_HLTTriggerTypeList.begin();
   o << "- -- Trigger type bits : " << c.m_HLTTriggerTypeList.size() << "  [ ";
   for (; triggerType != c.m_HLTTriggerTypeList.end(); ++triggerType) o << (*triggerType)->bit() << " ";
   o << "]" << std::endl;
 
 
   vector<TrigConf::HLTStreamTag*>::const_iterator streamTag = c.m_streams.begin();
   o << "- -- Trigger streams : " << c.m_streams.size() << std::endl;
   for (; streamTag   != c.m_streams.end();   ++streamTag)   o << *(*streamTag);
 
   vector<TrigConf::HLTSignature*>::const_iterator signature = c.m_HLTSignatureList.begin();
   for (; signature   != c.m_HLTSignatureList.end();   ++signature)   o << *(*signature);
   o << "- ---------------------------------------------------------- " << endl;
 
   o.precision(dp);
   return o;
}

operator<<() [2/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const HLTFrame &	f )

Definition at line 140 of file HLTFrame.cxx.

                                                               {
   o << "HLTFrame print: " << std::endl
     << "Running " << (f.mergedHLT() ? "":" not ") << "merged HLT" << std::endl
     << f.getHLTChainList()
     << f.getHLTSequenceList();
   return o;
}

operator<<() [3/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const HLTSequence &	s )

Definition at line 142 of file HLTSequence.cxx.

                                                                  {
   o << "- -- HLTSequence printout ---------------------------------- " << std::endl;
   o << "- -- inputTEs : ";
   bool first = true;
   for (TrigConf::HLTTriggerElement* inputTE : s.m_inputTEs) {
      if (first)
        first = false;
      else
        o << ", "; 
      o << *inputTE;
   }
 
   if (s.m_topoStartTE) {
      o << "\n";
      o << "- -- topoStartTE  ";
      o << *s.m_topoStartTE;
   }
   o << "\n- -- algorithms";
   first = true;
   for (const std::string& algorithm : s.m_algorithms) {
      if (first)
        first = false;
      else
        o << ", ";
      o << algorithm;
   }
   o << "\n- -- outputTE   : "; o << *s.outputTE();
   o << "\n- ---------------------------------------------------------- " << std::endl;
   return o;
}

operator<<() [4/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const HLTSequenceList &	sl )

Definition at line 124 of file HLTSequenceList.cxx.

                                                                       {
   o << "- -- HLTSequenceList printout ------------------------------ " << std::endl;
   for(TrigConf::HLTSequence* seq : sl) o << *seq;
   o << "- ---------------------------------------------------------- " << std::endl;
   return o;
}

operator<<() [5/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const HLTSignature &	s )

Definition at line 72 of file HLTSignature.cxx.

                                                                   {
   o << "signature: " << s.signature_counter() << " (logic=" << s.logic() << ")" << endl;
   o << "outputTE(s)";
 
   for( HLTTriggerElement* te : s.m_outputTEs ) {
      o << ", ";
      if( te!=0 ) o << *te; else o << "(0)";
   }
   o << endl;
   return o;
}

operator<<() [6/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const HLTTriggerElement &	te )

Definition at line 55 of file HLTTriggerElement.cxx.

                                                                 {
   o << "(\"" << te.name() << "\", " << te.m_hashId << ")";
   return o;
}

operator<<() [7/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const HLTTriggerType &	tt )

Definition at line 18 of file HLTTriggerType.cxx.

                                                                      {
  o << "- -- HLTTriggerType bit : " << tt.m_bit << std::endl;
  return o;
}

operator<<() [8/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const TrigConf::HLTPrescale &	c )

Definition at line 52 of file HLTPrescale.cxx.

                                                                  {
 
   o << "Prescale: " << setw(4) << c.prescale()
     << ", pass-through: " << setw(4) << c.pass_through()
     << endl;
   return o;
}

operator<<() [9/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const TrigConf::HLTPrescaleSet &	c )

Definition at line 147 of file HLTPrescaleSet.cxx.

                                                                     {
   o << "HLTPrescaleSet " << c.name();
   if(c.id()>0 || c.version()>0) o << " (id=" << c.id() << "/v=" << c.version() << ")";
   o << endl;
   if(c.comment()!="") o << "Comment    :    " << c.comment() << endl;
 
   for(unsigned int i = TrigConf::L2; i <= TrigConf::HLT; i++) {
      TrigConf::HLTLevel level = TrigConf::HLTLevel(i);
      if(c.size(level)==0) continue;
      o << (level==TrigConf::L2?"L2":"EF") << " prescales:" << endl;
      for(const TrigConf::HLTPrescaleSet::ScalingMap_t::value_type& sc: c.getPrescales(level)) {
         o << "Chain counter: " << setw(4) << sc.first
           << ", prescale: " << setw(4) << sc.second.prescale()
           << ", pass-through: " << setw(4) << sc.second.pass_through()
           << endl;
      }
   }
   o << "---------------------------------------------------------- " << endl;
   return o;
}

operator<<() [10/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const TrigConf::HLTPrescaleSetCollection &	c )

Definition at line 184 of file HLTPrescaleSetCollection.cxx.

                                                                               {
   lock_guard<recursive_mutex> lock(c.m_prescaleSetCollection_mutex);
   o << "HLTPrescaleSetCollection has " << c.size() << " prescale sets" << endl;
   if(c.size()>0) {
      o << "       LB   Prescale set key   Loaded   Prescale set" << endl;
      for(const TrigConf::HLTPrescaleSetCollection::cont& psinfo : c.m_prescaleSets)
         o << setw(9) << psinfo.lb << setw(19) << psinfo.psk << "   " << (psinfo.pss!=0?"yes":" no")
           << "   " << (psinfo.pss!=0?psinfo.pss->name():"") << endl;
   }
   return o;
}

operator<<() [11/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const TrigConf::HLTStreamTag &	st )

Definition at line 58 of file HLTStreamTag.cxx.

                                                                    {
   int dp = o.precision();
   o << "HLTStreamTag "
     << "stream: '"   << st.m_stream 
     << "' type: '"   << st.m_type
     << "' obeyLB: '"  << (st.m_obeyLB?"yes":"no");
   o.precision(3);
   o.setf(std::ios::fixed, std::ios::floatfield); 
   o << "' prescale: " << st.m_prescale
     << std::endl;
   o.precision(dp);
   return o;
}

operator<<() [12/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const TrigConf::TriggerItem &	item )

Definition at line 158 of file TriggerItem.cxx.

                                                                     {
   o << "TriggerItem: " << (const TrigConfData&)item;
   o << "   Complex Deadtime: " << item.m_ComplexDeadtime    << endl;
   o << "   Definition:       " << item.m_Definition  << endl;
   o << "   CTP_id:           " << item.m_CtpId       << endl;
   o << "   TriggerType(hex): " << hex << item.m_TriggerType << dec << endl;
   if (item.topNode()) o << *item.topNode();
   else o << "   No TopNode" << endl;
   return o;
}

operator<<() [13/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const TrigConfData &	data )

Definition at line 41 of file TrigConfData.cxx.

                                                                      {
   o <<  data.name();
   if(data.id()>0 || data.version()>0)
      o << " (id=" << data.id() << "/v=" << data.version() << ")";
   return o;
}

operator<<() [14/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const TrigConf::HLTChainList &	c )

Definition at line 189 of file HLTChainList.cxx.

                                                                    {
  o << "- -- HLTChainList [" << cl.size() << " chains] -------------------------------- " << std::endl;
  for(TrigConf::HLTChain* ch : cl)
     o << *ch;
  o << "- ---------------------------------------------------------- " << std::endl;
  return o;
}

operator<<() [15/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	o,
		const TrigConf::TriggerItemNode &	node )

Definition at line 308 of file TriggerItemNode.cxx.

                                                                         {
   o << "        TriggerItemNode: " << endl; 
   o << "           type        : " << (node.type()==TriggerItemNode::OBJ? "OBJ" : (node.type()==TriggerItemNode::AND?"AND":(node.type()==TriggerItemNode::OR?"OR":"NOT"))) << endl;
   o << "           position    : " << node.position() << endl;
 
   if (node.type() == TriggerItemNode::OBJ) {
      o << "  multiplicity: " << node.multiplicity() << endl;
      if ( node.triggerThreshold() ) {
         o << "  threshold   : " << node.thresholdName() << endl
           << node.triggerThreshold();
      } else if( node.isInternalTrigger() ) {
         o << "  InternalTrigger: " << node.thresholdName() << endl;
      } else {
         o << node.thresholdName() << endl;
      }
   }
   else {
      for(TriggerItemNode* subnode: node.children()) {
         o << "           subnodes : " << *subnode << endl;
      }
   }
   return o;
}

operator<<() [16/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	os,
		const TrigConf::IsolationLegacy &	iso )

Definition at line 338 of file L1ThresholdBase.cxx.

                                                                         {
   os << "isolation bit " << iso.isobit() << ":  offset=" << iso.offset() << ", slope=" << iso.slope() 
      << ", mincut=" << iso.mincut() << ", upperlimit=" << iso.upperlimit() 
      << ", etamin=" << iso.etamin() << ", etamax=" << iso.etamax() << ", priority=" << iso.priority();
   return os;
}

operator<<() [17/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	os,
		const TrigConf::L1ThrExtraInfo_cTAU::WorkingPoints_cTAU &	iso )

Definition at line 484 of file L1ThrExtraInfo.cxx.

                                                                                               {
   os << "isolation_fw=" << iso.isolation_fw() << ", isolation_jTAUCoreScale_fw=" << iso.isolation_jTAUCoreScale_fw();
   os << ", eTAU_rCoreMin_WP_fw=" << iso.eTAU_rCoreMin_WP_fw() << ", eTAU_rHadMin_WP_fw=" << iso.eTAU_rHadMin_WP_fw();
   return os;
}

operator<<() [18/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	os,
		const TrigConf::L1ThrExtraInfo_eEM::WorkingPoints_eEM &	iso )

Definition at line 294 of file L1ThrExtraInfo.cxx.

                                                                                             {
   os << "reta_fw=" << iso.reta_fw() << ", wstot_fw=" << iso.wstot_fw() << ", rhad_fw=" << iso.rhad_fw();
   return os;
}

operator<<() [19/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	os,
		const TrigConf::L1ThrExtraInfo_eTAU::WorkingPoints_eTAU &	iso )

Definition at line 388 of file L1ThrExtraInfo.cxx.

                                                                                               {
   os << "rCore_fw=" << iso.rCore_fw() << ", rHad_fw=" << iso.rHad_fw() ;
   return os;
}

operator<<() [20/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	os,
		const TrigConf::L1ThrExtraInfo_jEM::WorkingPoints_jEM &	iso )

Definition at line 338 of file L1ThrExtraInfo.cxx.

                                                                                             {
   os << "iso_fw=" << iso.iso_fw() << ", frac_fw=" << iso.frac_fw() << ", frac2_fw=" << iso.frac2_fw();
   return os;
}

operator<<() [21/21]

std::ostream & TrigConf::operator<<	(	std::ostream &	os,
		const TrigConf::L1ThrExtraInfo_jTAU::WorkingPoints_jTAU &	iso )

Definition at line 430 of file L1ThrExtraInfo.cxx.

                                                                                               {
   os << "isolation_fw=" << iso.isolation_fw() ;
   return os;
}

parse() [1/2]

TrigConf::TriggerItemNode * TrigConf::parse	(	const std::string &	logic,
		const std::vector< std::string > &	conditions,
		const std::vector< TrigConf::TriggerThreshold * > &	thrs )

Definition at line 243 of file Trigger/TrigConfiguration/TrigConfL1Data/Root/HelperFunctions.cxx.

                                                                  {
 
   // balance expression
   std::string expr = insertParenthesis(givenlogic);
 
   // parse
   TriggerItemNode* topNode = parseExpr(expr, conditions, thrs);
 
   // wrap in an AND
   if( topNode->type() != TriggerItemNode::AND) {
      TriggerItemNode * newNode = new TriggerItemNode(TriggerItemNode::AND);
      newNode->addChild(topNode);
      topNode = newNode;
   }
 
   return topNode;
}

parse() [2/2]

std::vector< std::string > TrigConf::parse

(

std::string

names

)

Definition at line 117 of file TrigConfHLTData/Root/HLTChain.cxx.

                          {
      std::erase(names,' ');
      return TrigConf::split(names,",");
   }

prepareTriggerMenu() [1/2]

StatusCode TrigConf::prepareTriggerMenu	(	const HLTMenu &	loadedHlt,
		const L1Menu &	loadedL1,
		const HLTPrescalesSet &	loadedHltps,
		const L1PrescalesSet &	loadedL1ps,
		const L1BunchGroupSet &	loadedBgSet,
		CTPConfig &	ctpConfig,
		HLTChainList &	chainList,
		HLTSequenceList &	sequenceList,
		BunchGroupSet &	bgSet,
		MsgStream &	msg )

Load JSON derived data into legacy structures to maintain compatiblity with existing code.

Parameters

loadedHlt	The incoming HLT trigger menu object to translate
loadedL1	The incoming L1 trigger menu object to translate
loadedHltps	The incoming HLT prescales menu object to translate
loadedL1ps	The incoming L1 prescales menu object to translate
loadedBg	The incoming bunchgroup object to translate
ctpConfig	The LVL1 configuration object to fill
chainList	The HLT configuration object to fill
bgSet	The bunch structure configuration object to fill
msg	MsgStream to print messages to

Returns

StatusCode::SUCCESS if successful, StatusCode::FAILURE if not

Definition at line 303 of file prepareTriggerMenu.cxx.

                                                  {
 
      // Clear the current LVL1 configuration:
      ctpConfig.menu().clear();
      ctpConfig.clearPrescaleSets();
      ctpConfig.prescaleSet().resize( 512 );
 
      if (loadedL1.isInitialized()) {
         // Fill the LVL1 configuration:
         for (const L1Item& loadedItem : loadedL1) {
            TriggerItem* item = new TriggerItem();
            item->setName( loadedItem.name() );
            item->setCtpId( loadedItem.ctpId() );
            ctpConfig.menu().addTriggerItem( item );
 
            float ps = -1.0;
            if (loadedL1ps.isInitialized()) {
               const L1PrescalesSet::L1Prescale& loadedPrescale = loadedL1ps.prescale( loadedItem.name() );
               ps = loadedPrescale.enabled ? static_cast< float >( loadedPrescale.prescale ) : -1.0;
            }
            ctpConfig.prescaleSet().setPrescale( loadedItem.ctpId(), ps );
            
            if( msg.level() <= MSG::VERBOSE ) {
               msg << MSG::VERBOSE << "L1 item " << loadedItem.name()
                  << " has ctpid " << loadedItem.ctpId()
                  << " and prescale " << ps 
                  << endmsg;
            }
         }
      }
 
      // Clear the current HLT configuration:
      chainList.clear();
      sequenceList.clear();
 
      // Fill the HLT configuration:
      if (loadedHlt.isInitialized()) {
         for (const Chain& loadedChain : loadedHlt) {
            // Figure out which level this chain is from:
            std::string level = "";
            if( loadedChain.name().find( "L2_" ) == 0 ) {
               level = "L2";
            } else if( loadedChain.name().find( "EF_" ) == 0 ) {
               level = "EF";
            } else if( loadedChain.name().find( "HLT_" ) == 0 ) {
               level = "HLT";
            } else {
               msg << MSG::WARNING << "prepareTriggerMenu(...): "
                   << "Couldn't figure out 'level' for chain: "
                   << loadedChain.name() << endmsg;
            }
 
            // An empty signature list for the chain:
            std::vector< HLTSignature* > signatures;
 
            // Optional Run2 payload
            std::vector<uint32_t> counters;
            std::vector<int> logics;
            std::vector<std::vector<std::string>> outputTEs;
            if (loadedChain.hasChild("signature")) {
               counters = ToVector<uint32_t>(loadedChain, "signature.counters");
               logics = ToVector<int>(loadedChain, "signature.logics");
               outputTEs = ToVectorVector<std::string>(loadedChain, "signature.outputTEs");
            }
 
            for( size_t sig = 0; sig < counters.size(); ++sig ) {
               std::vector< HLTTriggerElement* > outTEs;
               outTEs.reserve(outputTEs[ sig ].size());
               for( size_t outTEcounter = 0; outTEcounter< outputTEs[ sig ].size(); ++outTEcounter ) {
                  HLTTriggerElement* element = new HLTTriggerElement( outputTEs[ sig ][ outTEcounter ] );
                  outTEs.push_back( element );
               }
               HLTSignature* signature = new HLTSignature( counters[ sig ], logics[ sig ], std::move(outTEs) );
               signatures.push_back( signature );
               if( msg.level() <= MSG::VERBOSE ) {
                  msg << MSG::VERBOSE << "prepared signature: " << *( signatures.back() ) << endmsg;
               }
            }
 
            // Create the chain object:
            HLTChain* chain = new HLTChain( loadedChain.name(),
                                            loadedChain.counter(),
                                            1, // Chain version not important
                                            level,
                                            loadedChain.l1item(), // L1 seeds (string)
                                            -1, // Lower chain ID not important
                                            std::move(signatures) ); // Empty for R3 JSONs
 
            chain->set_rerun_prescale( -1.0 ); // Not used in R3
            chain->set_pass_through( -1.0 );  // Not used in R3
            chain->set_leg_multiplicities( loadedChain.legMultiplicities() );
 
            for (const std::string& group : loadedChain.groups()){
               chain->addGroup(group);
            }
 
            float ps = -1.0;
            if (loadedHltps.isInitialized()) {
               const HLTPrescalesSet::HLTPrescale& loadedPrescale = loadedHltps.prescale( loadedChain.name() );
               ps = loadedPrescale.enabled ? static_cast< float >( loadedPrescale.prescale ) : -1.0;
            }
            chain->set_prescale( ps );
 
            if( msg.level() <= MSG::VERBOSE ) {
               msg << MSG::VERBOSE << "chain " << loadedChain.name()
                   << " has counter " << loadedChain.counter()
                   << ", HLT prescale " << ps
                   << ", groups " << loadedChain.groups().size() << ", legs " << loadedChain.legMultiplicities().size()
                   << ", and " << counters.size() << " signatures (runs 1,2 only) " << endmsg;
            }
 
            // Add it to the list of chains:
            if( ! chainList.addHLTChain( chain ) ) {
               msg << MSG::FATAL << "prepareTriggerMenu(...): "
                   << "Couldn't add chain \"" << chain->name()
                   << "\"" << endmsg;
               delete chain;
               return StatusCode::FAILURE;
            }
         }
      }
 
      // Add sequence information if it's available (R1 or R2 menu):
      if( loadedHlt.hasChild("sequence_run2") ) {
         std::vector<std::string> menu_outputTEs = ToVector<std::string>(loadedHlt, "sequence_run2.outputTEs");
         std::vector<std::vector<std::string>> menu_inputTEs = ToVectorVector<std::string>(loadedHlt, "sequence_run2.inputTEs");
         std::vector<std::vector<std::string>> menu_algorithms = ToVectorVector<std::string>(loadedHlt, "sequence_run2.algorithms");
 
         for( size_t i = 0; i< menu_outputTEs.size(); ++i ) {
            HLTTriggerElement* outputTE = new HLTTriggerElement( menu_outputTEs[ i ] );
            std::vector< HLTTriggerElement* > inputTEs;
            for( size_t j = 0; j < menu_inputTEs[ i ].size(); ++j ) {
               HLTTriggerElement* te = new HLTTriggerElement( menu_inputTEs[ i ][ j ] );
               inputTEs.push_back( te );
            }
            HLTSequence* sequence = new HLTSequence( inputTEs, outputTE, menu_algorithms[ i ] );
            sequenceList.addHLTSequence( sequence );
            // This throws a runtime_error if it fails, which we don't need to
            // handle, since this is a FATAL error anyways.
         }
      }
 
      // Bunchgroup data is TODO
      // Create a new BunchGroupSet object, since an existing one can't be
      // modified... :-/
      BunchGroupSet bgSetNew;
 
      // Empty structure if data are missing
      if (!loadedBgSet) {
 
         for( size_t i = 0; i < 16; ++i ) {
            BunchGroup bg;
            bg.setInternalNumber(i);
            bgSetNew.addBunchGroup(bg);
         }
 
      } else {
 
         // Fill it with info:
         for( size_t i = 0; i < loadedBgSet.size(); ++i ) {
 
            const std::shared_ptr<L1BunchGroup> loadedBg = loadedBgSet.getBunchGroup(i);
 
            // Create a BunchGroup object:
            BunchGroup bg;
            bg.setInternalNumber(i);
 
            // Not the most efficient of copies, but one format has 16 bit ints whereas the other has 32 bit ints.
            for (const uint16_t b : loadedBg->bunches()) {
               bg.addBunch( static_cast<int>(b) );
            }
 
            // Add it to the set:
            bgSetNew.addBunchGroup(bg);
         }
 
      }
 
      static_assert(std::is_move_assignable<BunchGroupSet>::value);
      // Replace the current bunch-group set with the new one:
      bgSet = std::move(bgSetNew);
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

prepareTriggerMenu() [2/2]

StatusCode TrigConf::prepareTriggerMenu	(	const xAOD::TriggerMenu *	menu,
		CTPConfig &	ctpConfig,
		HLTChainList &	chainList,
		HLTSequenceList &	sequenceList,
		BunchGroupSet &	bgSet,
		MsgStream &	msg )

In order to avoid duplicating code between how the dual-use and the Athena-only code translates the xAOD metadata into the transient trigger configuration information, this function is used by both to achieve this.

Function providing translation for the transient configuration from the R2 AOD format.

Parameters

menu	The persistent trigger menu object to translate
ctpConfig	The LVL1 configuration object to fill
chainList	The HLT configuration object to fill
bgSet	The bunch structure configuration object to fill
msg	MsgStream to print messages to

Returns

StatusCode::SUCCESS if successful, StatusCode::FAILURE if not

Definition at line 47 of file prepareTriggerMenu.cxx.

                                                   {
 
      // A little sanity check:
      if( ( ! menu->hasStore() ) && ( ( ! menu->container() ) ||
                                      ( ! menu->container()->hasStore() ) ) ) {
         msg << MSG::FATAL << "prepareTriggerMenu(...) Received "
             << "xAOD::TriggerMenu object is not connected to an auxiliary "
             << "store" << endmsg;
         return StatusCode::FAILURE;
      }
 
      // Clear the current LVL1 configuration:
      ctpConfig.menu().clear();
      ctpConfig.clearPrescaleSets();
      ctpConfig.prescaleSet().resize( 512 );
 
      // Fill the LVL1 configuration:
      for( size_t i = 0; i < menu->itemCtpIds().size(); ++i ) {
         TriggerItem* item = new TriggerItem();
         item->setName( menu->itemNames()[ i ] );
         item->setCtpId( menu->itemCtpIds()[ i ] );
         ctpConfig.menu().addTriggerItem( item );
         if( menu->itemPrescalesAvailable() ) {
            ctpConfig.prescaleSet().setPrescale( menu->itemCtpIds()[ i ],
                         static_cast< float >( menu->itemPrescales()[ i ] ) );
         }
         if( msg.level() <= MSG::VERBOSE ) {
            msg << MSG::VERBOSE << "L1 item " << menu->itemNames()[ i ]
                << " has ctpid " << menu->itemCtpIds()[ i ] << endmsg;
         }
      }
 
      // Clear the current HLT configuration:
      chainList.clear();
      sequenceList.clear();
 
      // A helper variable:
      bool signatureWarningPrinted = false;
 
      // Fill the HLT configuration:
      for( size_t i = 0; i < menu->chainIds().size(); ++i ) {
 
         // Figure out which level this chain is from:
         std::string level = "";
         if( menu->chainNames()[ i ].find( "L2_" ) == 0 ) {
            level = "L2";
         } else if( menu->chainNames()[ i ].find( "EF_" ) == 0 ) {
            level = "EF";
         } else if( menu->chainNames()[ i ].find( "HLT_" ) == 0 ) {
            level = "HLT";
         } else {
            msg << MSG::WARNING << "prepareTriggerMenu(...): "
                << "Couldn't figure out 'level' for chain: "
                << menu->chainNames()[ i ] << endmsg;
         }
         // An empty signature list for the chain:
         std::vector< HLTSignature* > signatures;
 
         // If signature information is available, read it in:
         if( menu->chainSignatureCountersAvailable() &&
             menu->chainSignatureCounters().size() &&
             menu->chainSignatureLogicsAvailable() &&
             menu->chainSignatureLogics().size() &&
             menu->chainSignatureOutputTEsAvailable() &&
             menu->chainSignatureOutputTEs().size() /*&&
             menu->chainSignatureLabelsAvailable() &&
             menu->chainSignatureLabels().size() */) {
 
            const std::vector< uint32_t >& counters =
               menu->chainSignatureCounters()[ i ];
            const std::vector< int >& logics =
               menu->chainSignatureLogics()[ i ];
            const std::vector< std::vector< std::string > >& outputTEs =
               menu->chainSignatureOutputTEs()[ i ];
            /*
            const std::vector< std::string >& labels =
               menu->chainSignatureLabels()[ i ];
             */
 
            if( msg.level() <= MSG::VERBOSE ) {
               msg << MSG::VERBOSE << "chain " << menu->chainNames()[ i ]
                   << " has counter " << menu->chainIds()[ i ]
                   << " and " << counters.size() << " signatures" << endmsg;
            }
            for( size_t sig = 0; sig < counters.size(); ++sig ) {
               std::vector< HLTTriggerElement* > outTEs;
               outTEs.reserve(outputTEs[ sig ].size());
               for( size_t outTEcounter = 0;
                    outTEcounter< outputTEs[ sig ].size(); ++outTEcounter ) {
                  HLTTriggerElement* element =
                     new HLTTriggerElement( outputTEs[ sig ][ outTEcounter ] );
                  outTEs.push_back( element );
               }
               HLTSignature* signature =
                  new HLTSignature( counters[ sig ], logics[ sig ], std::move(outTEs) );
               signatures.push_back( signature );
               if( msg.level() <= MSG::VERBOSE ) {
                  msg << MSG::VERBOSE << "prepared signature: "
                      << *( signatures.back() ) << endmsg;
               }
            }
         } else if( ! signatureWarningPrinted ) {
            msg << MSG::WARNING << "prepareTriggerMenu(...): "
                << "HLT Signature information not available on the input"
                << endmsg;
            signatureWarningPrinted = true;
         }
 
         // Create the chain object:
         HLTChain* chain = new HLTChain( menu->chainNames()[ i ],
                                         menu->chainIds()[ i ],
                                         1, // Chain version not important
                                         level,
                                         menu->chainParentNames()[ i ],
                                         -1, // Lower chain ID not important
                                         std::move(signatures) );
         if( menu->chainRerunPrescalesAvailable() ) {
            chain->set_rerun_prescale( menu->chainRerunPrescales()[ i ] );
         }
         if( menu->chainPassthroughPrescalesAvailable() ) {
            chain->set_pass_through( menu->chainPassthroughPrescales()[ i ] );
         }
         if ( menu->chainPrescalesAvailable() ) {
             chain->set_prescale( menu->chainPrescales()[ i ]);
         }
         {
            auto parsed_multiplicities = ChainNameParser::multiplicities(menu->chainNames()[ i ]);
            std::vector<long unsigned int> leg_multiplicities(parsed_multiplicities.begin(), parsed_multiplicities.end());
            chain->set_leg_multiplicities( leg_multiplicities );
         }
         // Add it to the list of chains:
         if( ! chainList.addHLTChain( chain ) ) {
            msg << MSG::FATAL << "prepareTriggerMenu(...): "
                << "Couldn't add chain \"" << chain->name()
                << "\"" << endmsg;
            delete chain;
            return StatusCode::FAILURE;
         }
      }
 
      // Add sequence information if it's available:
      if( menu->sequenceInputTEsAvailable() &&
          menu->sequenceOutputTEsAvailable() &&
          menu->sequenceAlgorithmsAvailable() ) {
 
         for( size_t i = 0; i< menu->sequenceOutputTEs().size(); ++i ) {
            HLTTriggerElement* outputTE =
               new HLTTriggerElement( menu->sequenceOutputTEs()[ i ] );
            std::vector< HLTTriggerElement* > inputTEs;
            for( size_t j = 0; j < menu->sequenceInputTEs()[ i ].size(); ++j ) {
               HLTTriggerElement* te =
                  new HLTTriggerElement( menu->sequenceInputTEs()[ i ][ j ] );
               inputTEs.push_back( te );
            }
            HLTSequence* sequence =
               new HLTSequence( inputTEs, outputTE,
                                menu->sequenceAlgorithms()[ i ] );
            sequenceList.addHLTSequence( sequence );
            // This throws a runtime_error if it fails, which we don't need to
            // handle, since this is a FATAL error anyways.
         }
      } else {
         msg << MSG::WARNING << "prepareTriggerMenu(...): "
             << "HLT Sequence information not available on the input" << endmsg;
      }
 
      // Check if bunch-groups are available:
      if( menu->bunchGroupBunchesAvailable() ) {
 
         // Create a new BunchGroupSet object, since an existing one can't be
         // modified... :-/
         BunchGroupSet bgSetNew;
 
         // Fill it with info:
         for( size_t i = 0; i < menu->bunchGroupBunches().size(); ++i ) {
 
            // Create a BunchGroup object:
            BunchGroup bg;
            bg.setInternalNumber( i );
            std::vector< uint16_t >::const_iterator b_itr =
               menu->bunchGroupBunches()[ i ].begin();
            std::vector< uint16_t >::const_iterator b_end =
               menu->bunchGroupBunches()[ i ].end();
            for( ; b_itr != b_end; ++b_itr ) {
               bg.addBunch( *b_itr );
            }
 
            // Add it to the set:
            bgSetNew.addBunchGroup( bg );
         }
 
         // Replace the current bunch-group set with the new one:
         bgSet = bgSetNew;
 
      } else {
         msg << MSG::WARNING << "prepareTriggerMenu(...): "
             << "Bunch-group information not available on the "
             << "input" << endmsg;
      }
 
      // Let the user know what happened:
      msg << MSG::INFO << "Loaded xAOD::TriggerMenu configuration:" << endmsg;
      msg << MSG::INFO << "  SMK = " << menu->smk()
          << ", L1PSK = " << menu->l1psk()
          << ", HLTPSK = " << menu->hltpsk() << endmsg;
 
      // Return gracefully:
      return StatusCode::SUCCESS;
   }

printTable()

void TrigConf::printTable

(

const coral::ITable &

teTable

)

Definition at line 21 of file DBHelper.cxx.

                                              {
   const coral::ITableDescription & desc = table.description();
   for(int i=0; i<desc.numberOfColumns(); ++i) {
      const coral::IColumn & col = desc.columnDescription(i);
      std::cout << "   " << col.name() << std::endl;
   }
}

recursivelyFindOutputTEs()

void TrigConf::recursivelyFindOutputTEs	(	const std::string &	tename,
		const TrigConf::HLTSequenceList &	sequenceList,
		std::set< std::string > &	tes,
		int	level,
		const std::set< std::string > *	veto = 0 )

Definition at line 66 of file TrigConfHLTData/Root/HLTUtils.cxx.

   {
      if ( veto && veto->find(tename) != veto->end() ) return;
      TrigConf::HLTSequence* seq = sequenceList.getSequence(tename);
      if ( seq==0 ) return;
 
      if(level==2) seq->setL2(); 
      else if(level==3) seq->setEF(); 
      else if(level==4) seq->setHLT();
 
      tes.insert(tename);
      for( TrigConf::HLTTriggerElement* te : seq->inputTEs() )
         recursivelyFindOutputTEs( te->name(), sequenceList, tes, level, veto);
   }

recursivelyFindOutputTEsWithLevelFromSequence()

void TrigConf::recursivelyFindOutputTEsWithLevelFromSequence	(	const std::string &	tename,
		const TrigConf::HLTSequenceList &	sequenceList,
		std::set< std::string > &	tes,
		int	level )

Definition at line 86 of file TrigConfHLTData/Root/HLTUtils.cxx.

                                                                                      {
      
      // check if sequence exists that outputs this TE
      const TrigConf::HLTSequence* seq = sequenceList.getSequence(tename); 
      if ( seq==0 ) return;
 
      // it must know in which level it is running
      if(! seq->isSet()) { 
         std::stringstream str;
         str << "Sequence " << seq->outputTE()->name() << " has no level set " << std::endl;
         throw std::runtime_error(str.str());
      }
 
      // it must be the level that is requested
      if( (level==2 && !seq->inL2()) || (level==3 && !seq->inEF()) || (level==4 && !seq->inHLT()) ) return;
 
      // now insert the te and continue to check
      tes.insert(tename);
      for( TrigConf::HLTTriggerElement*  te : seq->inputTEs() )
         recursivelyFindOutputTEsWithLevelFromSequence( te->name(), sequenceList, tes, level);
   }

replaceTabs()

void TrigConf::replaceTabs

(

std::string &

str

)

Definition at line 38 of file Trigger/TrigConfiguration/TrigConfL1Data/Root/HelperFunctions.cxx.

                                         {
  std::replace(str.begin(), str.end(), '\t', ' ');
}

rmtilde()

std::string TrigConf::rmtilde ( const std::string & input )

inline

Definition at line 24 of file DBHelper.h.

{ return input=="~" ? "" : input; }

split()

std::vector< std::string > TrigConf::split	(	const std::string &	line,
		const std::string &	del = " " )

Definition at line 25 of file Trigger/TrigConfiguration/TrigConfL1Data/Root/HelperFunctions.cxx.

                                                           {
   std::vector<std::string> res;
   boost::split(res, line, boost::is_any_of(del));
   return res;
}

str2lvl()

HLTLevel TrigConf::str2lvl ( const std::string & level )

inline

Definition at line 14 of file HLTLevel.h.

                                                   {
      return (level=="L2" || level=="l2") ? L2 :
         ((level=="EF" || level=="ef") ? EF : HLT);
   }

stringToPtree()

void TrigConf::stringToPtree	(	const std::string &	json_string,
		boost::property_tree::ptree &	pt )

Definition at line 65 of file TrigDBHelper.cxx.

                                                                                     {
   boost::iostreams::array_source source(json_string.data(), json_string.size());
   boost::iostreams::stream<boost::iostreams::array_source> stream(source);
   boost::property_tree::read_json(stream, pt);
}

strip()

void TrigConf::strip

(

std::string &

str

)

Definition at line 33 of file Trigger/TrigConfiguration/TrigConfL1Data/Root/HelperFunctions.cxx.

                              {
  boost::algorithm::trim(str);
}

toLower()

void TrigConf::toLower

(

std::string &

s

)

Definition at line 45 of file Trigger/TrigConfiguration/TrigConfL1Data/Root/HelperFunctions.cxx.

                              {
  for(size_t i=0; i<s.size(); i++) s[i] += (s[i]>='A'&&s[i]<='Z')?'a'-'A':0;
}

ToVector()

template<typename T>

std::vector< T > TrigConf::ToVector	(	const TrigConf::DataStructure &	ds,
		const std::string &	child )

Helper function ptree key->[] to std::vector<T>

Definition at line 265 of file prepareTriggerMenu.cxx.

                                                                                 {
      using ptree = boost::property_tree::ptree;
      std::vector<T> return_vector;
      for( const ptree::value_type& entry : ds.data().get_child(child) ) {
         return_vector.push_back( entry.second.get_value<T>() );
      }
      return return_vector;
   }

ToVectorVector()

template<typename T>

std::vector< std::vector< T > > TrigConf::ToVectorVector	(	const TrigConf::DataStructure &	ds,
		const std::string &	child )

Helper function ptree key->[[]] to std::vector<std::vector<T>>

Definition at line 276 of file prepareTriggerMenu.cxx.

                                                                                                  {
      using ptree = boost::property_tree::ptree;
      std::vector<std::vector<T>> return_vector;
      for( const ptree::value_type& outer : ds.data().get_child(child) ) {
         return_vector.push_back(std::vector<T>());
         for (const ptree::value_type& inner : outer.second) {
            return_vector.back().push_back( inner.second.get_value<T>() );
         }
      }
      return return_vector;
   }

truncatedHash() [1/2]

uint32_t TrigConf::truncatedHash

(

const DataStructure &

dataStructure

)

Function to compute a truncated MD5 hash for a JSON file.

Trigger keys must be uint32_t whereas a MD5 is 128 bit. Used to generate a unique key for each MC JSON file to preserve JSON distinguishability upon merging of AOD files between MC campaigns.

Definition at line 23 of file TrigConfMD5.cxx.

                                                             {
    std::stringstream ss;
    dataStructure.printRaw(ss);
    return doTruncatedHash(ss);
  }

truncatedHash() [2/2]

uint32_t TrigConf::truncatedHash	(	const TrigConf::L1Menu &	L1DataStructure,
		const TrigConf::HLTMenu &	HLTDataStructure )

Function to compute a truncated MD5 hash for a JSON file.

Trigger keys must be uint32_t whereas a MD5 is 128 bit. Used to generate a unique key for both a L1 and HLT menu, mimicking a SMK

Definition at line 30 of file TrigConfMD5.cxx.

                                                                                                         {
    std::stringstream ss1;
    L1DataStructure.printRaw(ss1);
    std::stringstream ss2;
    HLTDataStructure.printRaw(ss2);
    std::stringstream ss_concatonate;
    ss_concatonate << ss2.str() << ss1.str();
    return doTruncatedHash(ss_concatonate);
  }

uint2bin()

std::string TrigConf::uint2bin	(	uint32_t	uinteger,
		uint16_t	width )

Definition at line 324 of file Trigger/TrigConfiguration/TrigConfL1Data/Root/HelperFunctions.cxx.

                                                 {
   stringstream ss;
   for(uint32_t mask = 1 << (width-1); mask>0; mask>>=1)
      ss << ( (value & mask) == 0 ? '0' : '1' );
 
   return ss.str();
}

writeRawFile() [1/2]

void TrigConf::writeRawFile	(	const coral::Blob &	data,
		const std::string &	outFileName )

write coral data blob to file

This is used by loader classes to write the DB content to file without going through a ptree

Parameters

data	[in] coral blob to be written
outFileName	[in] name of file to write out the loaded data (if an empty string, no file will be written)

Exceptions

TrigConf::JsonFileWritingException

if writing was successfull

Definition at line 72 of file TrigDBHelper.cxx.

{
   try {
      std::ofstream outFile(outFileName, std::ofstream::binary);
      if (!outFile) {
         throw FileWritingException(std::format("Failed to open file {} for writing", outFileName));
      }
      outFile.write( static_cast<const char*> ( data.startingAddress()), data.size() );
      if (!outFile) {
         throw FileWritingException("Failed to write data to file " + outFileName);
      }
      outFile.close();
   } catch (const std::exception& e) {
      throw FileWritingException(std::format("Exception while writing file {} : {}", outFileName, e.what()));
   }
}

writeRawFile() [2/2]

void TrigConf::writeRawFile	(	const std::string &	data,
		const std::string &	outFileName )

write string into file

This is used by loader classes to write the DB content from CREST to file without going through a ptree

Parameters

data	[in] crest data string to be written
outFileName	[in] name of file to write out the loaded data (if an empty string, no file will be written)

Exceptions

TrigConf::JsonFileWritingException

if writing was successfull

Definition at line 90 of file TrigDBHelper.cxx.

{
   try {
      std::ofstream outFile(outFileName, std::ofstream::binary);
      if (!outFile) {
         throw FileWritingException(std::format("Failed to open file {} for writing", outFileName));
      }
      outFile.write(data.data(), data.size());
      if (!outFile) {
         throw FileWritingException("Failed to write data to file " + outFileName);
      }
      outFile.close();
   } catch (const std::exception& e) {
      throw FileWritingException(std::format("Exception while writing file {} : {}", outFileName, e.what()));
   }
}

xAODKeysMatch() [1/2]

bool TrigConf::xAODKeysMatch	(	const xAOD::TrigConfKeys *	keys,
		const xAOD::TriggerMenu *	menu )

Since this is used in a couple of places, it seemed to make sense to put this simple code into a central place.

Helper function checking if the DB keys match on two objects.

Parameters

keys	The event identifier
menu	The trigger menu

Returns

true if the two objects match each other, false otherwise

Definition at line 20 of file xAODKeysMatch.cxx.

                                                     {
 
      return ( ( keys->smk() == menu->smk() ) &&
               ( keys->l1psk() == menu->l1psk() ) &&
               ( keys->hltpsk() == menu->hltpsk() ) );
   }

xAODKeysMatch() [2/2]

bool TrigConf::xAODKeysMatch	(	const xAOD::TriggerMenu *	menuA,
		const xAOD::TriggerMenu *	menuB )

Helper function checking if the DB keys match on two objects.

Parameters

menuA	One trigger menu
menuB	Another trigger menu

Returns

true if the two objects match each other, false otherwise

Definition at line 33 of file xAODKeysMatch.cxx.

                                                      {
 
      return ( ( menuA->smk() == menuB->smk() ) &&
               ( menuA->l1psk() == menuB->l1psk() ) &&
               ( menuA->hltpsk() == menuB->hltpsk() ) );
   }