l1t Namespace Reference

delete x; More...

Namespaces
	emtf
	stage1
	stage2

Classes
class	AlgorithmEvaluation
class	AMC13DumpToRaw
class	AMCDumpToRaw
class	Block
class	BlockHeader
class	BxBlock
class	BxBlockHeader
class	BXVectorInputProducer
class	CaloCluster
class	CaloCondition
class	CaloConfig
class	CaloConfigHelper
class	CaloEmCand
class	CaloMainProcessor
class	CaloParams
class	CaloParamsHelper
class	CaloParamsHelperO2O
class	CaloRegion
class	CaloSpare
class	CaloStage1Cluster
class	CaloStage1FirmwareFactory
class	CaloStage2JetAlgorithm
class	CaloStage2Nav
class	CaloStage2TowerAlgorithmFirmwareImp1
class	CaloTools
class	CaloTower
class	ClusterShapes
class	ConditionEvaluation
class	CorrCondition
class	CorrWithOverlapRemovalCondition
class	CPPFDigi
class	CTP7Payload
class	DataAlreadyPresentException
class	DataInvalidException
class	DataManager
class	DataWriter
class	DataWriterExt
class	Description
class	EGamma
class	EMTFDaqOut
class	EMTFHit
struct	EMTFPtLUT
class	EMTFRoad
class	EMTFTrack
class	EndCapParamsHelper
class	EnergySumCondition
class	EtSum
class	EtSumHelper
class	ExternalCondition
class	FakeInputProducer
class	GenToInputProducer
class	GlobalBoard
class	GlobalParamsHelper
class	GlobalScales
class	GMTInternalMuon
struct	GtConditionCategoryStringToEnum
struct	GtConditionTypeStringToEnum
class	GtInputDump
class	GtRecordDump
class	HGCalCluster
class	HGCalClusterT
class	HGCalMulticluster
class	HGCalTower
struct	HGCalTowerCoord
class	HGCalTowerID
class	HGCalTowerMap
class	HGCalTriggerCell
class	HGCFETriggerDigi
class	Interval
class	IntervalManager
class	Jet
class	L1Candidate
class	L1ComparatorRun2
class	L1DataEmulResult
struct	L1GtBoardTypeStringToEnum
class	L1TCaloRCTToUpgradeConverter
class	L1TCaloStage1LutWriter
class	L1TCaloTowersFilter
class	L1TCaloUpgradeToGCTConverter
class	L1TDigiToRaw
class	L1TExtCondLegacyToStage2
class	L1TExtCondProducer
class	L1TGlobalAnalyzer
class	L1TGlobalUtil
class	L1TGlobalUtilHelper
struct	L1TGtObjectStringToEnum
	the string to enum and enum to string conversions for GlobalObject More...
class	L1TRawToDigi
class	L1TStage1Layer2Producer
class	L1TStage2CaloAnalyzer
class	LUT
class	Mask
class	MicroGMTAbsoluteIsolationCheckLUT
class	MicroGMTAbsoluteIsolationCheckLUTFactory
class	MicroGMTCaloIndexSelectionLUT
class	MicroGMTCaloIndexSelectionLUTFactory
class	MicroGMTCancelOutUnit
class	MicroGMTConfiguration
class	MicroGMTExtrapolationLUT
class	MicroGMTExtrapolationLUTFactory
class	MicroGMTIsolationUnit
class	MicroGMTLUT
class	MicroGMTMatchQualFineLUT
class	MicroGMTMatchQualLUT
class	MicroGMTMatchQualLUTFactory
class	MicroGMTMatchQualSimpleLUT
class	MicroGMTRankPtQualLUT
class	MicroGMTRankPtQualLUTFactory
class	MicroGMTRelativeIsolationCheckLUT
class	MicroGMTRelativeIsolationCheckLUTFactory
class	MP7BufferDumpToRaw
class	MP7Payload
class	MTF7Payload
class	MuCondition
class	Muon
class	MuonCaloSum
class	MuonRawDigiTranslator
class	OMDSReader
class	OnlineDBqueryHelper
class	Packer
class	PackerFactory
class	PackerTokens
class	PackingSetup
class	PackingSetupFactory
class	Parameter
class	Payload
class	PhysicsToBitConverter
class	PrescalesVetosHelper
class	rctDataBase
class	RegionalMuonCand
class	RegionalMuonRawDigiTranslator
class	Stage1Layer2CentralityAlgorithm
class	Stage1Layer2DiTauAlgorithm
class	Stage1Layer2EGammaAlgorithm
class	Stage1Layer2EGammaAlgorithmImpHI
class	Stage1Layer2EGammaAlgorithmImpHW
class	Stage1Layer2EGammaAlgorithmImpPP
class	Stage1Layer2EtSumAlgorithm
class	Stage1Layer2EtSumAlgorithmImpHI
class	Stage1Layer2EtSumAlgorithmImpHW
class	Stage1Layer2EtSumAlgorithmImpPP
class	Stage1Layer2FirmwareFactory
class	Stage1Layer2FlowAlgorithm
class	Stage1Layer2HFBitCountAlgorithm
class	Stage1Layer2HFMinimumBias
class	Stage1Layer2HFRingSumAlgorithm
class	Stage1Layer2JetAlgorithm
class	Stage1Layer2JetAlgorithmImpHI
class	Stage1Layer2JetAlgorithmImpPP
class	Stage1Layer2JetAlgorithmImpSimpleHW
class	Stage1Layer2MainProcessor
class	Stage1Layer2MainProcessorFirmwareImp1
class	Stage1Layer2SingleTrackHI
class	Stage1Layer2TauAlgorithm
class	Stage1Layer2TauAlgorithmImpHW
class	Stage1Layer2TauAlgorithmImpPP
class	Stage1TauIsolationLUT
class	Stage2Layer1FirmwareFactory
class	Stage2Layer2ClusterAlgorithm
class	Stage2Layer2ClusterAlgorithmFirmwareImp1
class	Stage2Layer2DemuxEGAlgo
class	Stage2Layer2DemuxEGAlgoFirmwareImp1
class	Stage2Layer2DemuxJetAlgo
class	Stage2Layer2DemuxJetAlgoFirmwareImp1
class	Stage2Layer2DemuxSumsAlgo
class	Stage2Layer2DemuxSumsAlgoFirmwareImp1
class	Stage2Layer2DemuxTauAlgo
class	Stage2Layer2DemuxTauAlgoFirmwareImp1
class	Stage2Layer2EGAlgorithmFirmwareImp1
class	Stage2Layer2EGammaAlgorithm
class	Stage2Layer2EGammaAlgorithmFirmwareImp1
class	Stage2Layer2EtSumAlgorithm
class	Stage2Layer2EtSumAlgorithmFirmwareImp1
class	Stage2Layer2FirmwareFactory
class	Stage2Layer2JetAlgorithm
class	Stage2Layer2JetAlgorithmFirmwareImp1
class	Stage2Layer2JetSumAlgorithm
class	Stage2Layer2JetSumAlgorithmFirmwareImp1
class	Stage2Layer2MainProcessorFirmwareImp1
class	Stage2Layer2SumsAlgorithmFirmwareImp1
class	Stage2Layer2TauAlgorithm
class	Stage2Layer2TauAlgorithmFirmwareImp1
class	Stage2MainProcessor
class	Stage2MainProcessorFirmwareImp1
class	Stage2PreProcessor
class	Stage2PreProcessorFirmwareImp1
class	Stage2TowerCompressAlgorithm
class	Stage2TowerCompressAlgorithmFirmwareImp1
class	Stage2TowerDecompressAlgorithm
class	Stage2TowerDecompressAlgorithmFirmwareImp1
class	Tau
class	TriggerMenuParser
class	TriggerSystem
class	Unpacker
class	UnpackerCollections
class	UnpackerFactory
class	WriterProxy
class	WriterProxyT
class	XmlConfigParser

Typedefs
typedef std::map< std::string, GlobalAlgorithm >	AlgorithmMap
	map containing the algorithms More...
typedef std::vector< Block >	Blocks
typedef std::vector< BxBlock >	BxBlocks
typedef BXVector< CaloCluster >	CaloClusterBxCollection
typedef BXVector< CaloEmCand >	CaloEmCandBxCollection
typedef BXVector< CaloRegion >	CaloRegionBxCollection
typedef BXVector< CaloSpare >	CaloSpareBxCollection
typedef BXVector< CaloStage1Cluster >	CaloStage1ClusterBxCollection
typedef BXVector< CaloTower >	CaloTowerBxCollection
typedef AlgorithmMap::const_iterator	CItAlgo
	iterators through map containing the algorithms More...
typedef ConditionMap::const_iterator	CItCond
	iterators through map containing the conditions More...
typedef std::map< std::string, GlobalCondition * >	ConditionMap
typedef std::vector< CPPFDigi >	CPPFDigiCollection
typedef BXVector< EGamma >	EGammaBxCollection
typedef edm::Ref< EGammaBxCollection >	EGammaRef
typedef ObjectRefBxCollection< EGamma >	EGammaRefBxCollection
typedef ObjectRefPair< EGamma >	EGammaRefPair
typedef ObjectRefPairBxCollection< EGamma >	EGammaRefPairBxCollection
typedef edm::RefVector< EGammaBxCollection >	EGammaRefVector
typedef std::vector< EGammaRef >	EGammaVectorRef
typedef std::vector< EMTFDaqOut >	EMTFDaqOutCollection
typedef std::vector< EMTFHit >	EMTFHitCollection
typedef std::vector< EMTFRoad >	EMTFRoadCollection
typedef std::vector< EMTFTrack >	EMTFTrackCollection
typedef BXVector< EtSum >	EtSumBxCollection
typedef edm::Ref< EtSumBxCollection >	EtSumRef
typedef ObjectRefBxCollection< EtSum >	EtSumRefBxCollection
typedef ObjectRefPair< EtSum >	EtSumRefPair
typedef ObjectRefPairBxCollection< EtSum >	EtSumRefPairBxCollection
typedef edm::RefVector< EtSumBxCollection >	EtSumRefVector
typedef std::vector< EtSumRef >	EtSumVectorRef
typedef std::vector< GMTInternalMuon >	GMTInternalMuonCollection
typedef std::list< std::shared_ptr< GMTInternalMuon > >	GMTInternalMuonList
typedef std::map< int, std::vector< std::shared_ptr< GMTInternalMuon > > >	GMTInternalWedges
typedef BXVector< HGCalCluster >	HGCalClusterBxCollection
typedef BXVector< HGCalMulticluster >	HGCalMulticlusterBxCollection
typedef BXVector< HGCalTower >	HGCalTowerBxCollection
typedef BXVector< HGCalTowerMap >	HGCalTowerMapBxCollection
typedef BXVector< HGCalTriggerCell >	HGCalTriggerCellBxCollection
typedef edm::SortedCollection< HGCFETriggerDigi >	HGCFETriggerDigiCollection
typedef edm::Ptr< HGCFETriggerDigi >	HGCFETriggerDigiPtr
typedef std::vector< HGCFETriggerDigiPtr >	HGCFETriggerDigiPtrVector
typedef edm::Ref< HGCFETriggerDigiCollection >	HGCFETriggerDigiRef
typedef edm::RefVector< HGCFETriggerDigiCollection >	HGCFETriggerDigiRefVector
typedef AlgorithmMap::iterator	ItAlgo
typedef ConditionMap::iterator	ItCond
typedef BXVector< Jet >	JetBxCollection
typedef edm::Ref< JetBxCollection >	JetRef
typedef ObjectRefBxCollection< Jet >	JetRefBxCollection
typedef ObjectRefPair< Jet >	JetRefPair
typedef ObjectRefPairBxCollection< Jet >	JetRefPairBxCollection
typedef edm::RefVector< JetBxCollection >	JetRefVector
typedef std::vector< JetRef >	JetVectorRef
typedef BXVector< L1Candidate >	L1CandidateBxCollection
typedef edm::Ref< L1CandidateBxCollection >	L1CandidateRef
typedef edm::RefVector< L1CandidateBxCollection >	L1CandidateRefVector
typedef std::vector< L1CandidateRef >	L1CandidateVectorRef
typedef BXVector< L1DataEmulResult >	L1DataEmulResultBxCollection
typedef BXVector< Muon >	MuonBxCollection
typedef BXVector< MuonCaloSum >	MuonCaloSumBxCollection
typedef edm::Ref< MuonBxCollection >	MuonRef
typedef ObjectRefBxCollection< Muon >	MuonRefBxCollection
typedef ObjectRefPair< Muon >	MuonRefPair
typedef ObjectRefPairBxCollection< Muon >	MuonRefPairBxCollection
typedef edm::RefVector< MuonBxCollection >	MuonRefVector
typedef std::vector< MuonRef >	MuonVectorRef
template<typename T >
using	ObjectRef = edm::Ref< BXVector< T >>
template<typename T >
using	ObjectRefBxCollection = BXVector< ObjectRef< T >>
template<typename T >
using	ObjectRefPair = std::pair< edm::Ref< BXVector< T >>, edm::Ref< BXVector< T >>>
template<typename T >
using	ObjectRefPairBxCollection = BXVector< ObjectRefPair< T >>
typedef Packer *(	pack_fct) ()
typedef edmplugin::PluginFactory< pack_fct >	PackerFactoryT
typedef std::map< std::pair< int, int >, Packers >	PackerMap
typedef std::vector< std::shared_ptr< Packer > >	Packers
typedef edmplugin::PluginFactory< prov_fct >	PackingSetupFactoryT
typedef PackingSetup *(	prov_fct) ()
typedef BXVector< RegionalMuonCand >	RegionalMuonCandBxCollection
typedef ObjectRef< RegionalMuonCand >	RegionalMuonCandRef
typedef ObjectRefBxCollection< RegionalMuonCand >	RegionalMuonCandRefBxCollection
typedef ObjectRefPair< RegionalMuonCand >	RegionalMuonCandRefPair
typedef ObjectRefPairBxCollection< RegionalMuonCand >	RegionalMuonCandRefPairBxCollection
typedef BXVector< Tau >	TauBxCollection
typedef edm::Ref< TauBxCollection >	TauRef
typedef ObjectRefBxCollection< Tau >	TauRefBxCollection
typedef ObjectRefPair< Tau >	TauRefPair
typedef ObjectRefPairBxCollection< Tau >	TauRefPairBxCollection
typedef edm::RefVector< TauBxCollection >	TauRefVector
typedef std::vector< TauRef >	TauVectorRef
typedef Unpacker *(	unpack_fct) ()
typedef edmplugin::PluginFactory< unpack_fct >	UnpackerFactoryT
typedef std::map< int, std::shared_ptr< Unpacker > >	UnpackerMap
typedef edmplugin::PluginFactory< l1t::WriterProxy *()>	WriterFactory

Enumerations
enum	block_t { MP7 = 0, CTP7, MTF7 }
enum	cancel_t {   bmtf_bmtf, omtf_bmtf_pos, omtf_emtf_pos, omtf_omtf_pos,   emtf_emtf_pos, omtf_bmtf_neg, omtf_emtf_neg, omtf_omtf_neg,   emtf_emtf_neg }
enum	cancelmode { tracks, coordinate }
enum	GlobalObject {   gtMu, gtEG, gtJet, gtTau,   gtETM, gtETT, gtHTT, gtHTM,   gtETMHF, gtTowerCount, gtMinBiasHFP0, gtMinBiasHFM0,   gtMinBiasHFP1, gtMinBiasHFM1, gtETTem, gtAsymmetryEt,   gtAsymmetryHt, gtAsymmetryEtHF, gtAsymmetryHtHF, gtCentrality0,   gtCentrality1, gtCentrality2, gtCentrality3, gtCentrality4,   gtCentrality5, gtCentrality6, gtCentrality7, gtExternal,   ObjNull }
enum	GtConditionCategory {   CondNull, CondMuon, CondCalo, CondEnergySum,   CondCorrelation, CondExternal, CondCorrelationWithOverlapRemoval }
	condition categories More...
enum	GtConditionType {   TypeNull, Type1s, Type2s, Type2wsc,   Type2cor, Type3s, Type4s, TypeETM,   TypeETT, TypeHTT, TypeHTM, TypeETMHF,   TypeTowerCount, TypeMinBiasHFP0, TypeMinBiasHFM0, TypeMinBiasHFP1,   TypeMinBiasHFM1, TypeETTem, TypeExternal, Type2corWithOverlapRemoval,   TypeCent0, TypeCent1, TypeCent2, TypeCent3,   TypeCent4, TypeCent5, TypeCent6, TypeCent7,   TypeAsymEt, TypeAsymHt, TypeAsymEtHF, TypeAsymHtHF }
enum	L1GtBoardType { MP7 = 0, BoardNull }
	board types in GT More...
enum	tftype {   bmtf, omtf_neg, omtf_pos, emtf_neg,   emtf_pos }
enum	TrigFunc_t { COS, SIN }

Functions
void	calibrateAndRankJets (CaloParamsHelper const *params, const std::vector< l1t::Jet > *input, std::vector< l1t::Jet > *output)
void	calibrateAndRankTaus (CaloParamsHelper const *params, const std::vector< l1t::Tau > *input, std::vector< l1t::Tau > *output)
template<class T >
T	castTo (const char *arg)
template<>
bool	castTo< bool > (const char *arg)
template<>
char	castTo< char > (const char *arg)
template<>
double	castTo< double > (const char *arg)
template<>
float	castTo< float > (const char *arg)
template<>
int	castTo< int > (const char *arg)
template<>
long	castTo< long > (const char *arg)
template<>
long double	castTo< long double > (const char *arg)
template<>
long long	castTo< long long > (const char *arg)
template<>
short	castTo< short > (const char *arg)
template<>
unsigned char	castTo< unsigned char > (const char *arg)
template<>
unsigned int	castTo< unsigned int > (const char *arg)
template<>
unsigned long	castTo< unsigned long > (const char *arg)
template<>
unsigned long long	castTo< unsigned long long > (const char *arg)
template<>
unsigned short	castTo< unsigned short > (const char *arg)
template<class T >
T	castTo_impl (const char *arg, std::true_type, std::false_type)
template<class T >
T	castTo_impl (const char *arg, std::false_type, std::true_type)
template<class T >
T	castTo_impl (const char *arg, std::false_type, std::false_type)
template<class T >
T	castToInt_impl (const char *arg, std::true_type)
template<class T >
T	castToInt_impl (const char *arg, std::false_type)
l1t::LUT	convertToLUT (const std::vector< uint64_t > &v, int padding=-1) noexcept
l1t::LUT	convertToLUT (const std::vector< char > &v, int padding=-1) noexcept
l1t::LUT	convertToLUT (const std::vector< short > &v, int padding=-1) noexcept
l1t::LUT	convertToLUT (const std::vector< int > &v, int padding=-1) noexcept
l1t::LUT	convertToLUT (const std::vector< long > &v, int padding=-1) noexcept
l1t::LUT	convertToLUT (const std::vector< long long > &v, int padding=-1) noexcept
l1t::LUT	convertToLUT (const std::vector< unsigned char > &v, int padding=-1) noexcept
l1t::LUT	convertToLUT (const std::vector< unsigned short > &v, int padding=-1) noexcept
l1t::LUT	convertToLUT (const std::vector< unsigned int > &v, int padding=-1) noexcept
int	deltaGctPhi (const CaloRegion &region, const CaloRegion &neighbor)
void	EGammaToGtScales (CaloParamsHelper const *params, const std::vector< l1t::EGamma > *input, std::vector< l1t::EGamma > *output)
void	EtSumToGtScales (CaloParamsHelper const *params, const std::vector< l1t::EtSum > *input, std::vector< l1t::EtSum > *output)
void	getBXRange (int nbx, int &first, int &last)
const unsigned int	gtEta (const unsigned int iEta)
unsigned char	hgcal_bad_codec (0xff)
void	HICaloRingSubtraction (const std::vector< l1t::CaloRegion > &regions, std::vector< l1t::CaloRegion > *subRegions, CaloParamsHelper const *params)
	------------— For heavy ion ----------------------------------— More...
void	JetCalibration (std::vector< l1t::Jet > *uncalibjets, std::vector< double > jetCalibrationParams, std::vector< l1t::Jet > *jets, std::string jetCalibrationType, double jetLSB)
void	JetToGtEtaScales (CaloParamsHelper const *params, const std::vector< l1t::Jet > *input, std::vector< l1t::Jet > *output)
void	JetToGtPtScales (CaloParamsHelper const *params, const std::vector< l1t::Jet > *input, std::vector< l1t::Jet > *output)
std::string	l1GtBoardTypeEnumToString (const L1GtBoardType &)
L1GtBoardType	l1GtBoardTypeStringToEnum (const std::string &)
std::string	l1GtConditionCategoryEnumToString (const GtConditionCategory &)
GtConditionCategory	l1GtConditionCategoryStringToEnum (const std::string &)
std::string	l1GtConditionTypeEnumToString (const GtConditionType &)
GtConditionType	l1GtConditionTypeStringToEnum (const std::string &)
std::string	l1TGtObjectEnumToString (const GlobalObject &)
l1t::GlobalObject	l1TGtObjectStringToEnum (const std::string &)
std::ostream &	operator<< (std::ostream &os, const l1t::CaloParamsHelper &p)
bool	operator> (const l1t::Tau &a, const l1t::Tau &b)
bool	operator> (l1t::EGamma &a, l1t::EGamma &b)
bool	operator> (const l1t::EGamma &a, const l1t::EGamma &b)
bool	operator> (l1t::Tau &a, l1t::Tau &b)
bool	operator> (const l1t::Jet &a, const l1t::Jet &b)
bool	operator> (const l1t::Jet &a, l1t::Jet &b)
bool	operator> (const l1t::EGamma &a, l1t::EGamma &b)
bool	operator> (const l1t::Tau &a, l1t::Tau &b)
unsigned int	pack15bits (int pt, int eta, int phi)
unsigned int	pack16bits (int pt, int eta, int phi)
unsigned int	pack16bitsEgammaSpecial (int pt, int eta, int phi)
void	passThroughJets (const std::vector< l1t::CaloRegion > *regions, std::vector< l1t::Jet > *uncalibjets)
void	RegionCorrection (const std::vector< l1t::CaloRegion > &regions, std::vector< l1t::CaloRegion > *subRegions, CaloParamsHelper const *params)
	------— New region correction (PUsub, no response correction at the moment) --------— More...
void	simpleHWSubtraction (const std::vector< l1t::CaloRegion > &regions, std::vector< l1t::CaloRegion > *subRegions)
void	slidingWindowJetFinder (const int, const std::vector< l1t::CaloRegion > *regions, std::vector< l1t::Jet > *uncalibjets)
void	SortEGammas (std::vector< l1t::EGamma > *input, std::vector< l1t::EGamma > *output)
void	SortJets (std::vector< l1t::Jet > *input, std::vector< l1t::Jet > *output)
void	SortTaus (std::vector< l1t::Tau > *input, std::vector< l1t::Tau > *output)
void	TauToGtEtaScales (CaloParamsHelper const *params, const std::vector< l1t::Tau > *input, std::vector< l1t::Tau > *output)
void	TauToGtPtScales (CaloParamsHelper const *params, const std::vector< l1t::Tau > *input, std::vector< l1t::Tau > *output)
void	TwelveByTwelveFinder (const int, const std::vector< l1t::CaloRegion > *regions, std::vector< l1t::Jet > *uncalibjets)
void	TwoByTwoFinder (const int, const int, const std::vector< l1t::CaloRegion > *regions, std::vector< l1t::Jet > *uncalibjets)

Detailed Description

delete x;

map containing the conditions

Description: Simple Navigator class for the CaloTowers

Authors

: Sam Harper - RAL, Olivier Davignon - Bristol

Description: Firmware headers

Implementation: Collects concrete algorithm implmentations.

Author

: R. Alex Barbieri MIT Kalanand Mishra, Fermilab

Description: Firmware headers

Implementation: Collects concrete algorithm implmentations.

Author

: R. Alex Barbieri MIT

Description: Firmware headers

Implementation: Concrete firmware implementations

Author

: Jim Brooke - University of Bristol

Description: Firmware headers

Implementation: Concrete firmware implementations

Author

: Jim Brooke - University of Bristol Modified: Adam Elwood - ICL

Description: enums for the L1 GT.

Implementation: Defines various enums for CondFormats L1 GT. For each enum, define the lightweight "maps" for enum string label and enum value

Author

: Vladimir Rekovic, Brian Winer, OSU Vasile Mihai Ghete - HEPHY Vienna

$Date$ $Revision$

Typedef Documentation

typedef std::map<std::string, GlobalAlgorithm> l1t::AlgorithmMap

map containing the algorithms

Definition at line 32 of file TriggerMenuFwd.h.

typedef std::vector<Block> l1t::Blocks

Definition at line 72 of file Block.h.

typedef std::vector<BxBlock> l1t::BxBlocks

Definition at line 68 of file BxBlock.h.

typedef BXVector<CaloCluster> l1t::CaloClusterBxCollection

Definition at line 85 of file CaloCluster.h.

typedef BXVector<CaloEmCand> l1t::CaloEmCandBxCollection

Definition at line 26 of file CaloEmCand.h.

typedef BXVector<CaloRegion> l1t::CaloRegionBxCollection

Definition at line 47 of file CaloRegion.h.

typedef BXVector<CaloSpare> l1t::CaloSpareBxCollection

Definition at line 10 of file CaloSpare.h.

typedef BXVector<CaloStage1Cluster> l1t::CaloStage1ClusterBxCollection

Definition at line 27 of file CaloStage1Cluster.h.

typedef BXVector<CaloTower> l1t::CaloTowerBxCollection

Definition at line 10 of file CaloTower.h.

typedef AlgorithmMap::const_iterator l1t::CItAlgo

iterators through map containing the algorithms

Definition at line 39 of file TriggerMenuFwd.h.

typedef ConditionMap::const_iterator l1t::CItCond

iterators through map containing the conditions

Definition at line 35 of file TriggerMenuFwd.h.

typedef std::map<std::string, GlobalCondition*> l1t::ConditionMap

Definition at line 29 of file TriggerMenuFwd.h.

typedef std::vector<CPPFDigi> l1t::CPPFDigiCollection

Definition at line 68 of file CPPFDigi.h.

typedef BXVector<EGamma> l1t::EGammaBxCollection

Definition at line 11 of file EGamma.h.

typedef edm::Ref< EGammaBxCollection > l1t::EGammaRef

Definition at line 13 of file EGamma.h.

typedef ObjectRefBxCollection<EGamma> l1t::EGammaRefBxCollection

Definition at line 17 of file EGamma.h.

typedef ObjectRefPair<EGamma> l1t::EGammaRefPair

Definition at line 18 of file EGamma.h.

typedef ObjectRefPairBxCollection<EGamma> l1t::EGammaRefPairBxCollection

Definition at line 19 of file EGamma.h.

typedef edm::RefVector< EGammaBxCollection > l1t::EGammaRefVector

Definition at line 14 of file EGamma.h.

typedef std::vector< EGammaRef > l1t::EGammaVectorRef

Definition at line 15 of file EGamma.h.

typedef std::vector<EMTFDaqOut> l1t::EMTFDaqOutCollection

Definition at line 130 of file EMTFDaqOut.h.

typedef std::vector<EMTFHit> l1t::EMTFHitCollection

Definition at line 276 of file EMTFHit.h.

typedef std::vector<EMTFRoad> l1t::EMTFRoadCollection

Definition at line 62 of file EMTFRoad.h.

typedef std::vector<EMTFTrack> l1t::EMTFTrackCollection

Definition at line 204 of file EMTFTrack.h.

typedef BXVector<EtSum> l1t::EtSumBxCollection

Definition at line 11 of file EtSum.h.

typedef edm::Ref< EtSumBxCollection > l1t::EtSumRef

Definition at line 13 of file EtSum.h.

typedef ObjectRefBxCollection<EtSum> l1t::EtSumRefBxCollection

Definition at line 17 of file EtSum.h.

typedef ObjectRefPair<EtSum> l1t::EtSumRefPair

Definition at line 18 of file EtSum.h.

typedef ObjectRefPairBxCollection<EtSum> l1t::EtSumRefPairBxCollection

Definition at line 19 of file EtSum.h.

typedef edm::RefVector< EtSumBxCollection > l1t::EtSumRefVector

Definition at line 14 of file EtSum.h.

typedef std::vector< EtSumRef > l1t::EtSumVectorRef

Definition at line 15 of file EtSum.h.

typedef std::vector<GMTInternalMuon> l1t::GMTInternalMuonCollection

Definition at line 9 of file GMTInternalMuonFwd.h.

typedef std::list<std::shared_ptr<GMTInternalMuon> > l1t::GMTInternalMuonList

Definition at line 12 of file GMTInternalMuonFwd.h.

typedef std::map<int, std::vector<std::shared_ptr<GMTInternalMuon> > > l1t::GMTInternalWedges

Definition at line 11 of file GMTInternalMuonFwd.h.

typedef BXVector<HGCalCluster> l1t::HGCalClusterBxCollection

Definition at line 36 of file HGCalCluster.h.

typedef BXVector<HGCalMulticluster> l1t::HGCalMulticlusterBxCollection

Definition at line 29 of file HGCalMulticluster.h.

typedef BXVector<HGCalTower> l1t::HGCalTowerBxCollection

Definition at line 11 of file HGCalTower.h.

typedef BXVector<HGCalTowerMap> l1t::HGCalTowerMapBxCollection

Definition at line 12 of file HGCalTowerMap.h.

typedef BXVector<HGCalTriggerCell> l1t::HGCalTriggerCellBxCollection

Definition at line 13 of file HGCalTriggerCell.h.

typedef edm::SortedCollection<HGCFETriggerDigi> l1t::HGCFETriggerDigiCollection

Definition at line 15 of file HGCFETriggerDigiDefs.h.

typedef edm::Ptr<HGCFETriggerDigi> l1t::HGCFETriggerDigiPtr

Definition at line 20 of file HGCFETriggerDigiDefs.h.

typedef std::vector<HGCFETriggerDigiPtr> l1t::HGCFETriggerDigiPtrVector

Definition at line 21 of file HGCFETriggerDigiDefs.h.

typedef edm::Ref<HGCFETriggerDigiCollection> l1t::HGCFETriggerDigiRef

Definition at line 18 of file HGCFETriggerDigiDefs.h.

typedef edm::RefVector<HGCFETriggerDigiCollection> l1t::HGCFETriggerDigiRefVector

Definition at line 19 of file HGCFETriggerDigiDefs.h.

typedef AlgorithmMap::iterator l1t::ItAlgo

Definition at line 40 of file TriggerMenuFwd.h.

typedef ConditionMap::iterator l1t::ItCond

Definition at line 36 of file TriggerMenuFwd.h.

typedef BXVector<Jet> l1t::JetBxCollection

Definition at line 11 of file Jet.h.

typedef edm::Ref< JetBxCollection > l1t::JetRef

Definition at line 13 of file Jet.h.

typedef ObjectRefBxCollection<Jet> l1t::JetRefBxCollection

Definition at line 17 of file Jet.h.

typedef ObjectRefPair<Jet> l1t::JetRefPair

Definition at line 18 of file Jet.h.

typedef ObjectRefPairBxCollection<Jet> l1t::JetRefPairBxCollection

Definition at line 19 of file Jet.h.

typedef edm::RefVector< JetBxCollection > l1t::JetRefVector

Definition at line 14 of file Jet.h.

typedef std::vector< JetRef > l1t::JetVectorRef

Definition at line 15 of file Jet.h.

typedef BXVector<L1Candidate> l1t::L1CandidateBxCollection

Definition at line 9 of file L1Candidate.h.

typedef edm::Ref< L1CandidateBxCollection > l1t::L1CandidateRef

Definition at line 11 of file L1Candidate.h.

typedef edm::RefVector< L1CandidateBxCollection > l1t::L1CandidateRefVector

Definition at line 12 of file L1Candidate.h.

typedef std::vector< L1CandidateRef > l1t::L1CandidateVectorRef

Definition at line 13 of file L1Candidate.h.

typedef BXVector<L1DataEmulResult> l1t::L1DataEmulResultBxCollection

Definition at line 7 of file L1DataEmulResult.h.

typedef BXVector<Muon> l1t::MuonBxCollection

Definition at line 11 of file Muon.h.

typedef BXVector<MuonCaloSum> l1t::MuonCaloSumBxCollection

Definition at line 7 of file MuonCaloSumFwd.h.

typedef edm::Ref< MuonBxCollection > l1t::MuonRef

Definition at line 13 of file Muon.h.

typedef ObjectRefBxCollection<Muon> l1t::MuonRefBxCollection

Definition at line 17 of file Muon.h.

typedef ObjectRefPair<Muon> l1t::MuonRefPair

Definition at line 18 of file Muon.h.

typedef ObjectRefPairBxCollection<Muon> l1t::MuonRefPairBxCollection

Definition at line 19 of file Muon.h.

typedef edm::RefVector< MuonBxCollection > l1t::MuonRefVector

Definition at line 14 of file Muon.h.

typedef std::vector< MuonRef > l1t::MuonVectorRef

Definition at line 15 of file Muon.h.

template<typename T >

using l1t::ObjectRef = typedef edm::Ref<BXVector<T>>

Definition at line 10 of file L1TObjComparison.h.

template<typename T >

using l1t::ObjectRefBxCollection = typedef BXVector<ObjectRef<T>>

Definition at line 12 of file L1TObjComparison.h.

template<typename T >

using l1t::ObjectRefPair = typedef std::pair<edm::Ref<BXVector<T>>, edm::Ref<BXVector<T>>>

Definition at line 14 of file L1TObjComparison.h.

template<typename T >

using l1t::ObjectRefPairBxCollection = typedef BXVector<ObjectRefPair<T>>

Definition at line 16 of file L1TObjComparison.h.

typedef Packer*( l1t::pack_fct) ()

Definition at line 9 of file PackerFactory.h.

typedef edmplugin::PluginFactory<pack_fct> l1t::PackerFactoryT

Definition at line 10 of file PackerFactory.h.

typedef std::map<std::pair<int, int>, Packers> l1t::PackerMap

Definition at line 25 of file PackingSetup.h.

typedef std::vector<std::shared_ptr<Packer> > l1t::Packers

Definition at line 25 of file Packer.h.

typedef edmplugin::PluginFactory<prov_fct> l1t::PackingSetupFactoryT

Definition at line 10 of file PackingSetupFactory.h.

typedef PackingSetup*( l1t::prov_fct) ()

Definition at line 9 of file PackingSetupFactory.h.

typedef BXVector<RegionalMuonCand> l1t::RegionalMuonCandBxCollection

Definition at line 11 of file RegionalMuonCandFwd.h.

typedef ObjectRef<RegionalMuonCand> l1t::RegionalMuonCandRef

Definition at line 14 of file RegionalMuonCandFwd.h.

typedef ObjectRefBxCollection<RegionalMuonCand> l1t::RegionalMuonCandRefBxCollection

Definition at line 15 of file RegionalMuonCandFwd.h.

typedef ObjectRefPair<RegionalMuonCand> l1t::RegionalMuonCandRefPair

Definition at line 16 of file RegionalMuonCandFwd.h.

typedef ObjectRefPairBxCollection<RegionalMuonCand> l1t::RegionalMuonCandRefPairBxCollection

Definition at line 17 of file RegionalMuonCandFwd.h.

typedef BXVector<Tau> l1t::TauBxCollection

Definition at line 11 of file Tau.h.

typedef edm::Ref< TauBxCollection > l1t::TauRef

Definition at line 13 of file Tau.h.

typedef ObjectRefBxCollection<Tau> l1t::TauRefBxCollection

Definition at line 17 of file Tau.h.

typedef ObjectRefPair<Tau> l1t::TauRefPair

Definition at line 18 of file Tau.h.

typedef ObjectRefPairBxCollection<Tau> l1t::TauRefPairBxCollection

Definition at line 19 of file Tau.h.

typedef edm::RefVector< TauBxCollection > l1t::TauRefVector

Definition at line 14 of file Tau.h.

typedef std::vector< TauRef > l1t::TauVectorRef

Definition at line 15 of file Tau.h.

typedef Unpacker*( l1t::unpack_fct) ()

Definition at line 9 of file UnpackerFactory.h.

typedef edmplugin::PluginFactory<unpack_fct> l1t::UnpackerFactoryT

Definition at line 10 of file UnpackerFactory.h.

typedef std::map<int, std::shared_ptr<Unpacker> > l1t::UnpackerMap

Definition at line 27 of file PackingSetup.h.

typedef edmplugin::PluginFactory<l1t::WriterProxy * ()> l1t::WriterFactory

Definition at line 88 of file WriterProxy.h.

Enumeration Type Documentation

enum l1t::block_t

Enumerator
MP7
CTP7
MTF7

Definition at line 11 of file Block.h.

{ MP7 = 0, CTP7, MTF7 };

enum l1t::cancel_t

Enumerator
bmtf_bmtf
omtf_bmtf_pos
omtf_emtf_pos
omtf_omtf_pos
emtf_emtf_pos
omtf_bmtf_neg
omtf_emtf_neg
omtf_omtf_neg
emtf_emtf_neg

Definition at line 12 of file MicroGMTMatchQualLUT.h.

                  {
        bmtf_bmtf, omtf_bmtf_pos, omtf_emtf_pos, omtf_omtf_pos, emtf_emtf_pos, omtf_bmtf_neg, omtf_emtf_neg, omtf_omtf_neg, emtf_emtf_neg
    };

enum l1t::cancelmode

Enumerator
tracks
coordinate

Definition at line 11 of file MicroGMTCancelOutUnit.h.

                  {
    tracks, coordinate
  };

enum l1t::GlobalObject

L1 GT objects ObjNull catch all errors

Enumerator
gtMu
gtEG
gtJet
gtTau
gtETM
gtETT
gtHTT
gtHTM
gtETMHF
gtTowerCount
gtMinBiasHFP0
gtMinBiasHFM0
gtMinBiasHFP1
gtMinBiasHFM1
gtETTem
gtAsymmetryEt
gtAsymmetryHt
gtAsymmetryEtHF
gtAsymmetryHtHF
gtCentrality0
gtCentrality1
gtCentrality2
gtCentrality3
gtCentrality4
gtCentrality5
gtCentrality6
gtCentrality7
gtExternal
ObjNull

Definition at line 16 of file GlobalObject.h.

{
    gtMu,
    gtEG,
    gtJet,
    gtTau,
    gtETM,
    gtETT,
    gtHTT,
    gtHTM,
    gtETMHF,
    gtTowerCount,
    gtMinBiasHFP0,
    gtMinBiasHFM0,
    gtMinBiasHFP1,
    gtMinBiasHFM1,
    gtETTem,
    gtAsymmetryEt,
    gtAsymmetryHt,
    gtAsymmetryEtHF,
    gtAsymmetryHtHF,
    gtCentrality0,
    gtCentrality1,
    gtCentrality2,
    gtCentrality3,
    gtCentrality4,
    gtCentrality5,
    gtCentrality6,
    gtCentrality7,
    gtExternal,
    ObjNull
};

enum l1t::GtConditionCategory

condition categories

Enumerator
CondNull
CondMuon
CondCalo
CondEnergySum
CondCorrelation
CondExternal
CondCorrelationWithOverlapRemoval

Definition at line 96 of file GlobalDefinitions.h.

                         {
    CondNull,
    CondMuon,
    CondCalo,
    CondEnergySum,
    CondCorrelation,
    CondExternal,
    CondCorrelationWithOverlapRemoval
};

enum l1t::GtConditionType

condition types TypeNull: null type - for condition constructor only Type1s : one particle Type2s : two particles, same type, no spatial correlations among them Type2wsc : two particles, same type, with spatial correlations among them Type2cor : two particles, different type, with spatial correlations among them Type3s : three particles, same type Type4s : four particles, same type TypeETM, TypeETT, TypeHTT, TypeHTM : ETM, ETT, HTT, HTM TypeExternal: external conditions (logical result only; definition in L1 GT external systems)

Enumerator
TypeNull
Type1s
Type2s
Type2wsc
Type2cor
Type3s
Type4s
TypeETM
TypeETT
TypeHTT
TypeHTM
TypeETMHF
TypeTowerCount
TypeMinBiasHFP0
TypeMinBiasHFM0
TypeMinBiasHFP1
TypeMinBiasHFM1
TypeETTem
TypeExternal
Type2corWithOverlapRemoval
TypeCent0
TypeCent1
TypeCent2
TypeCent3
TypeCent4
TypeCent5
TypeCent6
TypeCent7
TypeAsymEt
TypeAsymHt
TypeAsymEtHF
TypeAsymHtHF

Definition at line 52 of file GlobalDefinitions.h.

                     {
    TypeNull,
    Type1s,
    Type2s,
    Type2wsc,
    Type2cor,
    Type3s,
    Type4s,
    TypeETM,
    TypeETT,
    TypeHTT,
    TypeHTM,
    TypeETMHF,
    TypeTowerCount,
    TypeMinBiasHFP0,
    TypeMinBiasHFM0,
    TypeMinBiasHFP1,
    TypeMinBiasHFM1,
    TypeETTem,
    TypeExternal,
    Type2corWithOverlapRemoval,
    TypeCent0,
    TypeCent1,
    TypeCent2,
    TypeCent3,
    TypeCent4,
    TypeCent5,
    TypeCent6,
    TypeCent7,
    TypeAsymEt,
    TypeAsymHt,
    TypeAsymEtHF,
    TypeAsymHtHF
};

enum l1t::L1GtBoardType

board types in GT

Enumerator
MP7
BoardNull

Definition at line 28 of file GlobalDefinitions.h.

                   {
    MP7,
    BoardNull
};

enum l1t::tftype

Enumerator
bmtf
omtf_neg
omtf_pos
emtf_neg
emtf_pos

Definition at line 8 of file RegionalMuonCandFwd.h.

              {
    bmtf, omtf_neg, omtf_pos, emtf_neg, emtf_pos
  };

enum l1t::TrigFunc_t

Enumerator
COS
SIN

Definition at line 55 of file TriggerMenuParser.h.

{ COS, SIN } TrigFunc_t;

Function Documentation

void l1t::calibrateAndRankJets	(	CaloParamsHelper const *	params,
		const std::vector< l1t::Jet > *	input,
		std::vector< l1t::Jet > *	output
	)

Definition at line 12 of file legacyGtHelper.cc.

References l1t::LUT::data(), PVValHelper::eta, l1t::CaloParamsHelper::jetCalibrationLUT(), PFRecoTauDiscriminationByIsolation_cfi::offset, and EnergyCorrector::pt.

Referenced by l1t::Stage1Layer2JetAlgorithmImpSimpleHW::processEvent().

                                          {

    for(std::vector<l1t::Jet>::const_iterator itJet = input->begin();
    itJet != input->end(); ++itJet){
      unsigned int pt = itJet->hwPt();
      if(pt > ((1<<10) -1) )
    pt = ((1<<10) -1);
      unsigned int eta = itJet->hwEta();
      if (eta>10){ // LUT is symmetric in eta. For eta>10 map to corresponding eta<10 bin
    int offset=2*(eta-10)-1;
    eta=eta-offset;
      }
      unsigned int lutAddress = (eta<<10)+pt;

      unsigned int rank = params->jetCalibrationLUT()->data(lutAddress);

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
      l1t::Jet outJet(*&ldummy, rank, itJet->hwEta(), itJet->hwPhi(), itJet->hwQual());
      output->push_back(outJet);
    }
  }

void l1t::calibrateAndRankTaus	(	CaloParamsHelper const *	params,
		const std::vector< l1t::Tau > *	input,
		std::vector< l1t::Tau > *	output
	)

Definition at line 36 of file legacyGtHelper.cc.

References l1t::LUT::data(), PVValHelper::eta, EnergyCorrector::pt, and l1t::CaloParamsHelper::tauCalibrationLUT().

Referenced by l1t::Stage1Layer2TauAlgorithmImpHW::processEvent().

                                          {

    for(std::vector<l1t::Tau>::const_iterator itTau = input->begin();
    itTau != input->end(); ++itTau){
      unsigned int pt = itTau->hwPt();
      if(pt > ((1<<10) -1) )
    pt = ((1<<10) -1);
      unsigned int eta = itTau->hwEta();
      unsigned int lutAddress = (eta<<10)+pt;

      unsigned int rank = params->tauCalibrationLUT()->data(lutAddress);

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
      l1t::Tau outTau(*&ldummy, rank, itTau->hwEta(), itTau->hwPhi(), itTau->hwQual());
      output->push_back(outTau);
    }
  }

template<class T >

T l1t::castTo

(

const char *

arg

)

Definition at line 133 of file Parameter.h.

                                            {
    return castTo_impl<T>(arg, std::is_integral<T>(), std::is_floating_point<T>());
}

template<>

bool l1t::castTo< bool >

(

const char *

arg

)

Definition at line 80 of file Parameter.cc.

References nullptr.

Referenced by l1t::Parameter::~Parameter().

                                                { 
    if( strlen(arg) > 3 ){
        // look for "true"
        if( strstr(arg,"true") != nullptr && strstr(arg,"false") == nullptr ) return true;
        // look for "false"
        if( strstr(arg,"true") == nullptr && strstr(arg,"false") != nullptr ) return false;
    }
    // look for "a number
    char *endptr = nullptr;
    long retval = strtol(arg,&endptr,0);
    if( *endptr == '\0' ) return retval;
    // nothing worked
    throw runtime_error("Cannot convert '" + string(arg)+ "' to boolean");
}

template<>

char l1t::castTo< char >

(

const char *

arg

)

Definition at line 95 of file Parameter.cc.

References castTo< long long >().

Referenced by l1t::Parameter::~Parameter().

{ return castTo<long long>(arg); }

template<>

double l1t::castTo< double >

(

const char *

arg

)

Definition at line 107 of file Parameter.cc.

References castTo< long double >().

Referenced by l1t::Parameter::~Parameter().

{ return castTo<long double>(arg); }

template<>

float l1t::castTo< float >

(

const char *

arg

)

Definition at line 106 of file Parameter.cc.

References castTo< long double >().

Referenced by l1t::Parameter::~Parameter().

{ return castTo<long double>(arg); }

template<>

int l1t::castTo< int >

(

const char *

arg

)

Definition at line 97 of file Parameter.cc.

References castTo< long long >().

Referenced by l1t::Parameter::~Parameter().

{ return castTo<long long>(arg); }

template<>

long l1t::castTo< long >

(

const char *

arg

)

Definition at line 98 of file Parameter.cc.

References castTo< long long >().

Referenced by l1t::Parameter::~Parameter().

{ return castTo<long long>(arg); }

template<>

long double l1t::castTo< long double >

(

const char *

arg

)

Definition at line 100 of file Parameter.cc.

Referenced by castTo< double >(), castTo< float >(), castTo_impl(), and l1t::Parameter::~Parameter().

                                                            {
    char *endptr = nullptr;
    long double retval = strtold(arg,&endptr);
    if( *endptr == '\0' ) return retval;
    else throw runtime_error("Cannot convert '" + string(arg) + "' to floating point type");
}

template<>

long long l1t::castTo< long long >

(

const char *

arg

)

Definition at line 72 of file Parameter.cc.

Referenced by castTo< char >(), castTo< int >(), castTo< long >(), castTo< short >(), castToInt_impl(), and l1t::Parameter::~Parameter().

                                                        {
    char *endptr = nullptr;
    long long retval = strtoll(arg,&endptr,0);
    if( *endptr == '\0' ) return retval;
    else throw runtime_error("Cannot convert '" + string(arg)+ "' to integral type");
}

template<>

short l1t::castTo< short >

(

const char *

arg

)

Definition at line 96 of file Parameter.cc.

References castTo< long long >().

Referenced by l1t::Parameter::~Parameter().

{ return castTo<long long>(arg); }

template<>

unsigned char l1t::castTo< unsigned char >

(

const char *

arg

)

Definition at line 115 of file Parameter.cc.

References castTo< unsigned long long >().

Referenced by l1t::Parameter::~Parameter().

{ return castTo<unsigned long long>(arg); }

template<>

unsigned int l1t::castTo< unsigned int >

(

const char *

arg

)

Definition at line 117 of file Parameter.cc.

References castTo< unsigned long long >().

Referenced by l1t::Parameter::~Parameter().

{ return castTo<unsigned long long>(arg); }

template<>

unsigned long l1t::castTo< unsigned long >

(

const char *

arg

)

Definition at line 118 of file Parameter.cc.

References castTo< unsigned long long >().

Referenced by l1t::Parameter::~Parameter().

{ return castTo<unsigned long long>(arg); }

template<>

unsigned long long l1t::castTo< unsigned long long >

(

const char *

arg

)

Definition at line 109 of file Parameter.cc.

Referenced by castTo< unsigned char >(), castTo< unsigned int >(), castTo< unsigned long >(), castTo< unsigned short >(), castToInt_impl(), and l1t::Parameter::~Parameter().

                                                                          {
    char *endptr = nullptr;
    unsigned long long retval = strtoull(arg,&endptr,0);
    if( *endptr == '\0' ) return retval;
    else throw runtime_error("Cannot convert '" + string(arg)+ "' to unsigned integral type");
}

template<>

unsigned short l1t::castTo< unsigned short >

(

const char *

arg

)

Definition at line 116 of file Parameter.cc.

References castTo< unsigned long long >().

Referenced by l1t::Parameter::~Parameter().

{ return castTo<unsigned long long>(arg); }

template<class T >

T l1t::castTo_impl	(	const char *	arg,
		std::true_type	,
		std::false_type
	)

Definition at line 137 of file Parameter.h.

Referenced by l1t::Parameter::~Parameter().

                                                                             {
    return castToInt_impl<T>(arg, std::is_unsigned<T>());
}

template<class T >

T l1t::castTo_impl	(	const char *	arg,
		std::false_type	,
		std::true_type
	)

Definition at line 149 of file Parameter.h.

References castTo< long double >().

                                                                             {
    return castTo<long double>(arg);
}

template<class T >

T l1t::castTo_impl	(	const char *	arg,
		std::false_type	,
		std::false_type
	)

Definition at line 153 of file Parameter.h.

                                                                               {
    return T(arg);
}

template<class T >

T l1t::castToInt_impl	(	const char *	arg,
		std::true_type
	)

Definition at line 141 of file Parameter.h.

References castTo< unsigned long long >().

Referenced by l1t::Parameter::~Parameter().

                                                                 {
    return castTo<unsigned long long>(arg);
}

template<class T >

T l1t::castToInt_impl	(	const char *	arg,
		std::false_type
	)

Definition at line 145 of file Parameter.h.

References castTo< long long >().

                                                                  {
    return castTo<long long>(arg);
}

l1t::LUT l1t::convertToLUT ( const std::vector< uint64_t > &  v, int  padding = -1  )

noexcept

Definition at line 10 of file ConvertToLUT.h.

References mps_fire::i, lumiPlot::lut, and l1t::LUT::read().

Referenced by convertToLUT(), L1TMuonGlobalParamsHelper::loadFromOnline(), and L1TCaloParamsOnlineProd::readCaloLayer2OnlineSettings().

                                                                           {

    unsigned int addrWidth = ( 32 - __builtin_clz( uint32_t(v.size()-1) ) );
    std::stringstream oss;
    oss << "#<header> V1 " << addrWidth << " 31 </header> " << std::endl; // hardcode 32 bits for data
    for(unsigned int i=0; i<v.size(); i++) oss << i << " " << v[i] << std::endl;
    // add padding to 2^addrWidth rows
    if( padding >=0 )
        for(unsigned int i=v.size(); i<(size_t)(1<<addrWidth); i++)
            oss << i << " " << padding << std::endl;

    l1t::LUT lut;
    lut.read(oss);

    return lut;
}

l1t::LUT l1t::convertToLUT ( const std::vector< char > &  v, int  padding = -1  )

noexcept

Definition at line 27 of file ConvertToLUT.h.

References convertToLUT().

                                                                       {
    return convertToLUT(std::vector<uint64_t>(v.begin(),v.end()), padding);
}

l1t::LUT l1t::convertToLUT ( const std::vector< short > &  v, int  padding = -1  )

noexcept

Definition at line 30 of file ConvertToLUT.h.

References convertToLUT().

                                                                        {
    return convertToLUT(std::vector<uint64_t>(v.begin(),v.end()), padding);
}

l1t::LUT l1t::convertToLUT ( const std::vector< int > &  v, int  padding = -1  )

noexcept

Definition at line 33 of file ConvertToLUT.h.

References convertToLUT().

                                                                      {
    return convertToLUT(std::vector<uint64_t>(v.begin(),v.end()), padding);
}

l1t::LUT l1t::convertToLUT ( const std::vector< long > &  v, int  padding = -1  )

noexcept

Definition at line 36 of file ConvertToLUT.h.

References convertToLUT().

                                                                       {
    return convertToLUT(std::vector<uint64_t>(v.begin(),v.end()), padding);
}

l1t::LUT l1t::convertToLUT ( const std::vector< long long > &  v, int  padding = -1  )

noexcept

Definition at line 39 of file ConvertToLUT.h.

References convertToLUT().

                                                                            {
    return convertToLUT(std::vector<uint64_t>(v.begin(),v.end()), padding);
}

l1t::LUT l1t::convertToLUT ( const std::vector< unsigned char > &  v, int  padding = -1  )

noexcept

Definition at line 42 of file ConvertToLUT.h.

References convertToLUT().

                                                                                {
    return convertToLUT(std::vector<uint64_t>(v.begin(),v.end()), padding);
}

l1t::LUT l1t::convertToLUT ( const std::vector< unsigned short > &  v, int  padding = -1  )

noexcept

Definition at line 45 of file ConvertToLUT.h.

References convertToLUT().

                                                                                 {
    return convertToLUT(std::vector<uint64_t>(v.begin(),v.end()), padding);
}

l1t::LUT l1t::convertToLUT ( const std::vector< unsigned int > &  v, int  padding = -1  )

noexcept

Definition at line 48 of file ConvertToLUT.h.

References convertToLUT().

                                                                               {
    return convertToLUT(std::vector<uint64_t>(v.begin(),v.end()), padding);
}

int l1t::deltaGctPhi	(	const CaloRegion &	region,
		const CaloRegion &	neighbor
	)

Definition at line 18 of file JetFinderMethods.cc.

References funct::abs(), diffTreeTool::diff, l1t::L1Candidate::hwPhi(), and L1CaloRegionDetId::N_PHI.

Referenced by slidingWindowJetFinder(), TwelveByTwelveFinder(), and TwoByTwoFinder().

  {
    int phi1 = region.hwPhi();
    int phi2 = neighbor.hwPhi();
    int diff = phi1 - phi2;
    if (std::abs(phi1 - phi2) == L1CaloRegionDetId::N_PHI-1) { //18 regions in phi
      diff = -diff/std::abs(diff);
    }
    return diff;
  }

void l1t::EGammaToGtScales	(	CaloParamsHelper const *	params,
		const std::vector< l1t::EGamma > *	input,
		std::vector< l1t::EGamma > *	output
	)

Definition at line 99 of file legacyGtHelper.cc.

References gtEta().

Referenced by l1t::Stage1Layer2EGammaAlgorithmImpPP::processEvent(), l1t::Stage1Layer2EGammaAlgorithmImpHI::processEvent(), and l1t::Stage1Layer2EGammaAlgorithmImpHW::processEvent().

                                         {

    for(std::vector<l1t::EGamma>::const_iterator itEGamma = input->begin();
    itEGamma != input->end(); ++itEGamma){
      unsigned newEta = gtEta(itEGamma->hwEta());
      unsigned newPhi = itEGamma->hwPhi();
      const uint16_t rankPt = (uint16_t)itEGamma->hwPt(); //max value?

      //hwQual &10 == 10 means that the object came from a sort and is padding
      if((itEGamma->hwQual() & 0x10) == 0x10)
      {
    newEta = 0x0;
    newPhi = 0x0;
      }

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::EGamma gtEGamma(*&ldummy, rankPt, newEta, newPhi,
               itEGamma->hwQual(), itEGamma->hwIso());
      output->push_back(gtEGamma);
    }
  }

void l1t::EtSumToGtScales	(	CaloParamsHelper const *	params,
		const std::vector< l1t::EtSum > *	input,
		std::vector< l1t::EtSum > *	output
	)

Definition at line 165 of file legacyGtHelper.cc.

References L1Analysis::kMissingHt.

Referenced by l1t::Stage1Layer2EtSumAlgorithmImpPP::processEvent(), l1t::Stage1Layer2EtSumAlgorithmImpHW::processEvent(), and l1t::Stage1Layer2EtSumAlgorithmImpHI::processEvent().

                                           {
    for(std::vector<l1t::EtSum>::const_iterator itEtSum = input->begin();
    itEtSum != input->end(); ++itEtSum){

      uint16_t rankPt;
      // Hack for now to make sure they come out with the right scale
      //rankPt = params->jetScale().rank((uint16_t)itEtSum->hwPt());
      rankPt = (uint16_t)itEtSum->hwPt();
      if (EtSum::EtSumType::kMissingHt == itEtSum->getType())
      {
    // if(rankPt > params->HtMissScale().linScaleMax()) rankPt = params->HtMissScale().linScaleMax();
    // params->HtMissScale().linScaleMax() always returns zero.  Hardcode 512 for now

    // comment out for mht/ht (already in GT scale)
    //if(rankPt > 512) rankPt = 512;
    //rankPt = params->HtMissScale().rank(rankPt*params->emScale().linearLsb());
      }

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::EtSum gtEtSum(*&ldummy, itEtSum->getType(), rankPt, 0,
             itEtSum->hwPhi(), itEtSum->hwQual());

      output->push_back(gtEtSum);
    }
  }

void l1t::getBXRange	(	int	nbx,
		int &	first,
		int &	last
	)

Definition at line 13 of file UnpackerFactory.cc.

References min().

Referenced by process(), l1t::stage1::CaloSpareHFUnpacker::unpack(), l1t::stage1::EtSumUnpacker::unpack(), l1t::stage1::MissEtUnpacker::unpack(), l1t::stage1::MissHtUnpacker::unpack(), l1t::stage1::legacy::HFRingUnpacker::unpack(), l1t::stage1::legacy::EtSumUnpacker::unpack(), l1t::stage2::RegionalMuonGMTUnpacker::unpack(), l1t::stage2::MuonUnpacker::unpack(), l1t::stage2::IntermediateMuonUnpacker::unpack(), l1t::stage2::BMTFUnpackerOutput::unpack(), l1t::stage1::unpack_em(), and l1t::stage1::unpack_region().

   {
      last = std::floor(nbx / 2.);
      first = std::min(0, -last + (1 - nbx % 2));
   }

const unsigned int l1t::gtEta

(

const unsigned int

iEta

)

Definition at line 194 of file legacyGtHelper.cc.

Referenced by EGammaToGtScales(), JetToGtEtaScales(), l1t::Stage2Layer2DemuxJetAlgoFirmwareImp1::processEvent(), and TauToGtEtaScales().

  {
    unsigned rctEta = (iEta<11 ? 10-iEta : iEta-11);
    return (((rctEta % 7) & 0x7) | (iEta<11 ? 0x8 : 0));
  }

unsigned char l1t::hgcal_bad_codec

(

0xff

)

Referenced by l1t::HGCFETriggerDigi::encode().

void l1t::HICaloRingSubtraction	(	const std::vector< l1t::CaloRegion > &	regions,
		std::vector< l1t::CaloRegion > *	subRegions,
		CaloParamsHelper const *	params
	)

------------— For heavy ion ----------------------------------—

Definition at line 19 of file PUSubtractionMethods.cc.

References mps_fire::i, SiStripPI::max, and L1CaloRegionDetId::N_ETA.

Referenced by l1t::Stage1Layer2SingleTrackHI::processEvent(), l1t::Stage1Layer2JetAlgorithmImpHI::processEvent(), and RegionCorrection().

  {
    int puLevelHI[L1CaloRegionDetId::N_ETA];

    for(unsigned i = 0; i < L1CaloRegionDetId::N_ETA; ++i)
    {
      puLevelHI[i] = 0;
    }

    for(std::vector<CaloRegion>::const_iterator region = regions.begin();
    region != regions.end(); region++){
      puLevelHI[region->hwEta()] += region->hwPt();
    }

    for(unsigned i = 0; i < L1CaloRegionDetId::N_ETA; ++i)
    {
      //puLevelHI[i] = floor(((double)puLevelHI[i] / (double)L1CaloRegionDetId::N_PHI)+0.5);
      puLevelHI[i] = (puLevelHI[i] + 9) * 455 / (1 << 13); // approx equals X/18 +0.5
    }

    for(std::vector<CaloRegion>::const_iterator region = regions.begin(); region!= regions.end(); region++){
      int subPt = std::max(0, region->hwPt() - puLevelHI[region->hwEta()]);
      int subEta = region->hwEta();
      int subPhi = region->hwPhi();


      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      CaloRegion newSubRegion(*&ldummy, 0, 0, subPt, subEta, subPhi, region->hwQual(), region->hwEtEm(), region->hwEtHad());
      subRegions->push_back(newSubRegion);
    }
  }

void l1t::JetCalibration	(	std::vector< l1t::Jet > *	uncalibjets,
		std::vector< double >	jetCalibrationParams,
		std::vector< l1t::Jet > *	jets,
		std::string	jetCalibrationType,
		double	jetLSB
	)

Definition at line 12 of file JetCalibrationMethods.cc.

References alpha, CustomPhysics_cfi::gamma, createfilelist::int, reco::btau::jetEta, reco::btau::jetPhi, and reco::btau::jetPt.

Referenced by l1t::Stage1Layer2EtSumAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2JetAlgorithmImpPP::processEvent().

  {

    for (std::vector<l1t::Jet>::const_iterator uncalibjet = uncalibjets->begin(); uncalibjet != uncalibjets->end(); ++uncalibjet){

      if (jetCalibrationType == "None") {
    l1t::Jet corrjets = *uncalibjet;
    jets->push_back(corrjets);
    continue;
      }

      if (jetCalibrationType == "Stage1JEC") {
    int jetPt = (uncalibjet->hwPt())*jetLSB;  // correction factors are parameterized as functions of physical pt
    int jetPhi = uncalibjet->hwPhi();
    int jetEta = uncalibjet->hwEta();
    int jetQual = uncalibjet->hwQual();
    double jpt = 0.0;

    double alpha = jetCalibrationParams[2*jetEta + 0]; //Scale factor (See jetSF_cfi.py)
    double gamma = ((jetCalibrationParams[2*jetEta + 1])); //Offset

    jpt = jetPt*alpha+gamma;
    unsigned int corjetET =(int) (jpt/jetLSB);

    ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
    l1t::Jet corrjets(*&jetLorentz, corjetET, jetEta, jetPhi, jetQual);

    jets->push_back(corrjets);
      }
    }
  }

void l1t::JetToGtEtaScales	(	CaloParamsHelper const *	params,
		const std::vector< l1t::Jet > *	input,
		std::vector< l1t::Jet > *	output
	)

Definition at line 57 of file legacyGtHelper.cc.

References gtEta(), and gtJet.

Referenced by l1t::Stage1Layer2JetAlgorithmImpHI::processEvent(), l1t::Stage1Layer2JetAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2JetAlgorithmImpSimpleHW::processEvent().

                                      {

    for(std::vector<l1t::Jet>::const_iterator itJet = input->begin();
    itJet != input->end(); ++itJet){
      unsigned newPhi = itJet->hwPhi();
      unsigned newEta = gtEta(itJet->hwEta());

      // jets with hwQual & 10 ==10 are "padding" jets from a sort, set their eta and phi
      // to the max value
      if((itJet->hwQual() & 0x10) == 0x10)
      {
    newEta = 0x0;
    newPhi = 0x0;
      }

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::Jet gtJet(*&ldummy, itJet->hwPt(), newEta, newPhi, itJet->hwQual());
      output->push_back(gtJet);
    }
  }

void l1t::JetToGtPtScales	(	CaloParamsHelper const *	params,
		const std::vector< l1t::Jet > *	input,
		std::vector< l1t::Jet > *	output
	)

Definition at line 81 of file legacyGtHelper.cc.

References gtJet, l1t::CaloParamsHelper::jetScale(), L1CaloEtScale::linScaleMax(), and L1CaloEtScale::rank().

Referenced by l1t::Stage1Layer2JetAlgorithmImpHI::processEvent(), and l1t::Stage1Layer2JetAlgorithmImpPP::processEvent().

                                      {

    for(std::vector<l1t::Jet>::const_iterator itJet = input->begin();
    itJet != input->end(); ++itJet){
      uint16_t linPt = (uint16_t)itJet->hwPt();
      if(linPt > params->jetScale().linScaleMax() ) linPt = params->jetScale().linScaleMax();
      const uint16_t rankPt = params->jetScale().rank(linPt);

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::Jet gtJet(*&ldummy, rankPt, itJet->hwEta(), itJet->hwPhi(), itJet->hwQual());
      output->push_back(gtJet);
    }
  }

std::string l1t::l1GtBoardTypeEnumToString

(

const L1GtBoardType &

boardType

)

Definition at line 121 of file GlobalDefinitions.cc.

References BoardNull, and mps_fire::result.

                                                                          {
    char const *result= valueToKey(boardType, l1GtBoardTypeStringToEnumMap);
    if (boardType == l1t::BoardNull) {
        edm::LogInfo("L1TGlobal")
                << "\n  l1t::BoardNull means no valid board type defined!";
    }
    if (!result) {
      edm::LogInfo("L1TGlobal") << "\n  '" << boardType
                  << "' is not a recognized l1t::L1GtBoardType. "
                  << "\n  Return l1t::BoardNull, which means no valid board type defined!";
      return "l1t::BoardNull";
    }
    return result;
}

l1t::L1GtBoardType l1t::l1GtBoardTypeStringToEnum

(

const std::string &

label

)

Definition at line 105 of file GlobalDefinitions.cc.

References BoardNull, BoardNull, and relativeConstraints::value.

                                                                      {
    l1t::L1GtBoardType value = keyToValue(label.c_str(), l1GtBoardTypeStringToEnumMap);
    if (value == (l1t::L1GtBoardType) - 1) {
        edm::LogInfo("L1TGlobal") << "\n  '" << label
                << "' is not a recognized l1t::L1GtBoardType. \n  Return l1t::BoardNull.";
        value = l1t::BoardNull;
    }

    if (value == l1t::BoardNull) {
        edm::LogInfo("L1TGlobal")
                << "\n  l1t::BoardNull means no valid board type defined!";
    }

    return value;
}

std::string l1t::l1GtConditionCategoryEnumToString

(

const GtConditionCategory &

conditionCategory

)

Definition at line 193 of file GlobalDefinitions.cc.

References CondNull, and mps_fire::result.

                                                                                                {
  char const *result = valueToKey(conditionCategory, l1GtConditionCategoryStringToEnumMap);
  if (conditionCategory == l1t::CondNull)
    edm::LogInfo("L1TGlobal")
            << "\n  Return l1t::CondNull, which means no valid condition category defined!";
    
  if (!result) {
    result = "l1t::CondNull";
    edm::LogInfo("L1TGlobal") << "\n  '" << conditionCategory
            << "' is not a recognized l1t::GtConditionCategory. "
            << "\n  Return l1t::CondNull, which means no valid condition category defined!";
  }

  return result;
}

l1t::GtConditionCategory l1t::l1GtConditionCategoryStringToEnum

(

const std::string &

label

)

Definition at line 174 of file GlobalDefinitions.cc.

References CondNull, CondNull, and relativeConstraints::value.

                                                                                    {
  l1t::GtConditionCategory value = keyToValue(label.c_str(), l1GtConditionCategoryStringToEnumMap);
  // in case of unrecognized l1t::GtConditionCategory, return l1t::CondNull
  // to be dealt by the corresponding module
  if (value == (l1t::GtConditionCategory) -1) {
    edm::LogInfo("L1TGlobal") << "\n  '" << label
            << "' is not a recognized l1t::GtConditionCategory. \n  Return l1t::CondNull.";

    value = l1t::CondNull;
  }

  if (value == l1t::CondNull) {
      edm::LogInfo("L1TGlobal")
              << "\n  l1t::CondNull means no valid condition category defined!";
  }

  return value;
}

std::string l1t::l1GtConditionTypeEnumToString

(

const GtConditionType &

conditionType

)

Definition at line 160 of file GlobalDefinitions.cc.

References mps_fire::result, and TypeNull.

                                                                                    {
  const char *result = valueToKey(conditionType, l1GtConditionTypeStringToEnumMap);
  if (conditionType == l1t::TypeNull)
    edm::LogInfo("L1TGlobal") 
      << "\n  Return l1t::TypeNull, which means no valid condition type defined!";
  if (!result) {
    result = "l1t::TypeNull";
    edm::LogInfo("L1TGlobal") << "\n  '" << conditionType
            << "' is not a recognized l1t::GtConditionType. "
            << "\n  Return l1t::TypeNull, which means no valid condition type defined!";
  }
  return result;
}

l1t::GtConditionType l1t::l1GtConditionTypeStringToEnum

(

const std::string &

label

)

Definition at line 140 of file GlobalDefinitions.cc.

References TypeNull, TypeNull, and relativeConstraints::value.

                                                                            {
    l1t::GtConditionType value = keyToValue(label.c_str(), l1GtConditionTypeStringToEnumMap);

    // in case of unrecognized l1t::GtConditionType, return l1t::TypeNull
    // to be dealt by the corresponding module
    if (value == (l1t::GtConditionType) -1) {
        edm::LogInfo("L1TGlobal")  << "\n  '" << label
                << "' is not a recognized l1t::GtConditionType. \n  Return l1t::TypeNull.";

        value = l1t::TypeNull;
    }

    if (value == l1t::TypeNull) {
        edm::LogInfo("L1TGlobal")
                << "\n  l1t::TypeNull means no valid condition type defined!";
    }

    return value;
}

std::string l1t::l1TGtObjectEnumToString

(

const GlobalObject &

gtObject

)

Definition at line 90 of file GlobalObject.cc.

References gtAsymmetryEt, gtAsymmetryEtHF, gtAsymmetryHt, gtAsymmetryHtHF, gtCentrality0, gtCentrality1, gtCentrality2, gtCentrality3, gtCentrality4, gtCentrality5, gtCentrality6, gtCentrality7, gtEG, gtETM, gtETMHF, gtETT, gtETTem, gtExternal, gtHTM, gtHTT, gtJet, gtMinBiasHFM0, gtMinBiasHFM1, gtMinBiasHFP0, gtMinBiasHFP1, gtMu, gtTau, gtTowerCount, ObjNull, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by l1t::CorrCondition::evaluateCondition(), and l1t::CorrWithOverlapRemovalCondition::evaluateCondition().

                                                                   {

    std::string gtObjectString;

    switch (gtObject) {

        case gtMu: {
            gtObjectString = "Mu";
        }
            break;

        case gtEG: {
            gtObjectString = "EG";
        }
            break;

        case gtTau: {
            gtObjectString = "Tau";
        }
            break;

        case gtJet: {
            gtObjectString = "Jet";
        }
            break;

        case gtETM: {
            gtObjectString = "ETM";
        }
            break;

        case gtETT: {
            gtObjectString = "ETT";
        }
            break;

        case gtHTT: {
            gtObjectString = "HTT";
        }
            break;

        case gtHTM: {
            gtObjectString = "HTM";
        }
            break;

        case gtETMHF: {
            gtObjectString = "ETMHF";
        }
            break;

        case gtTowerCount: {
            gtObjectString = "TowerCount";
        }
            break;

        case gtMinBiasHFP0: {
            gtObjectString = "MinBiasHFP0";
        }
            break;

        case gtMinBiasHFM0: {
            gtObjectString = "MinBiasHFM0";
        }
            break;

        case gtMinBiasHFP1: {
            gtObjectString = "MinBiasHFP1";
        }
            break;

        case gtMinBiasHFM1: {
            gtObjectString = "MinBiasHFM1";
        }
            break;

        case gtETTem: {
            gtObjectString = "ETTem";
        }
            break;

        case gtAsymmetryEt: {
            gtObjectString = "AsymEt";
        }
            break;

        case gtAsymmetryHt: {
            gtObjectString = "AsymHt";
        }
            break;

        case gtAsymmetryEtHF: {
            gtObjectString = "AsymEtHF";
        }
            break;

        case gtAsymmetryHtHF: {
            gtObjectString = "AsymHtHF";
        }
            break;

        case gtCentrality0: {
            gtObjectString = "CENT0";
        }
            break;

        case gtCentrality1: {
            gtObjectString = "CENT1";
        }
            break;

        case gtCentrality2: {
            gtObjectString = "CENT2";
        }
            break;

        case gtCentrality3: {
            gtObjectString = "CENT3";
        }
            break;

        case gtCentrality4: {
            gtObjectString = "CENT4";
        }
            break;

        case gtCentrality5: {
            gtObjectString = "CENT5";
        }
            break;

        case gtCentrality6: {
            gtObjectString = "CENT6";
        }
            break;

        case gtCentrality7: {
            gtObjectString = "CENT7";
        }
            break;

        case gtExternal: {
            gtObjectString = "External";
        }
            break;

        case ObjNull: {
            gtObjectString = "ObjNull";
            edm::LogInfo("L1TGlobal")
                    << "\n  ObjNull means no valid GlobalObject defined!";
        }
            break;

        default: {
            edm::LogInfo("L1TGlobal") << "\n  '" << gtObject
                    << "' is not a recognized GlobalObject. "
                    << "\n  Return ObjNull, which means no valid GlobalObject defined!";

            gtObjectString = "ObjNull";

        }
            break;
    }

    return gtObjectString;

}

l1t::GlobalObject l1t::l1TGtObjectStringToEnum

(

const std::string &

)

Definition at line 27 of file GlobalObject.cc.

References runEdmFileComparison::found, gtAsymmetryEt, gtAsymmetryEtHF, gtAsymmetryHt, gtAsymmetryHtHF, gtCentrality0, gtCentrality1, gtCentrality2, gtCentrality3, gtCentrality4, gtCentrality5, gtCentrality6, gtCentrality7, gtEG, gtETM, gtETMHF, gtETT, gtETTem, gtExternal, gtHTM, gtHTT, gtJet, gtMinBiasHFM0, gtMinBiasHFM1, gtMinBiasHFP0, gtMinBiasHFP1, gtMu, gtTau, gtTowerCount, mps_fire::i, l1t::L1TGtObjectStringToEnum::label, ObjNull, relativeConstraints::value, and l1t::L1TGtObjectStringToEnum::value.

                                                                {

     
    
    static const l1t::L1TGtObjectStringToEnum l1TGtObjectStringToEnumMap[] = {
            {"Mu",  gtMu},
            {"EG",  gtEG},
        {"Tau", gtTau},
            {"Jet", gtJet},
            {"ETM", gtETM},
            {"ETT", gtETT},
            {"HTT", gtHTT},
            {"HTM", gtHTM},
        {"ETMHF", gtETMHF},
        {"TowerCount",gtTowerCount},
        {"MinBiasHFP0", gtMinBiasHFP0},
        {"MinBiasHFM0", gtMinBiasHFM0},
        {"MinBiasHFP1", gtMinBiasHFP1},
        {"MinBiasHFM1", gtMinBiasHFM1},
        {"ETTem", gtETTem},
        {"AsymEt", gtAsymmetryEt},
        {"AsymHt", gtAsymmetryHt},
        {"AsymEtHF", gtAsymmetryEtHF},
        {"AsymEtHF", gtAsymmetryHtHF},
        {"CENT0", gtCentrality0},
        {"CENT1", gtCentrality1},
        {"CENT2", gtCentrality2},
        {"CENT3", gtCentrality3},
        {"CENT4", gtCentrality4},
        {"CENT5", gtCentrality5},
        {"CENT6", gtCentrality6},
        {"CENT7", gtCentrality7},
            {"External", gtExternal},
            {"ObjNull", ObjNull},
            {nullptr, (GlobalObject) - 1}
    };

    l1t::GlobalObject value = (GlobalObject) - 1;

    bool found = false;
    for (int i = 0; l1TGtObjectStringToEnumMap[i].label && (!found); ++i)
        if (!std::strcmp(label.c_str(), l1TGtObjectStringToEnumMap[i].label)) {
            found = true;
            value = l1TGtObjectStringToEnumMap[i].value;
        }

    // in case of unrecognized GlobalObject, returns Mu
    // and write a warning (to not throw an exception)
    if (!found) {
        edm::LogInfo("L1TGlobal") << "\n  '" << label
                << "' is not a recognized GlobalObject. \n  Return ObjNull.";

        value = ObjNull;
    }

    if (value == ObjNull) {
        edm::LogInfo("L1TGlobal")
                << "\n  ObjNull means no valid GlobalObject defined!";
    }

    return value;
}

std::ostream & l1t::operator<<	(	std::ostream &	os,
		const l1t::CaloParamsHelper &	p
	)

Definition at line 17 of file CaloParamsHelper.cc.

                                                                       {
    return os << "CaloParamsHelper...";
  }

bool l1t::operator>	(	const l1t::Tau &	a,
		const l1t::Tau &	b
	)

Definition at line 17 of file Stage2Layer2TauAlgorithmFirmwareImp1.cc.

References reco::LeafCandidate::pt().

  {
    return a.pt() > b.pt();
  }

bool l1t::operator> ( l1t::EGamma &  a, l1t::EGamma &  b  )

inline

Definition at line 18 of file Stage2Layer2DemuxEGAlgoFirmwareImp1.cc.

References l1t::L1Candidate::hwEta(), l1t::L1Candidate::hwPhi(), and reco::LeafCandidate::pt().

  {
    if ( a.pt() == b.pt() ){
      if( a.hwPhi() == b.hwPhi() ){
    return a.hwEta() > b.hwEta();
      }
      else{
      return a.hwPhi() > b.hwPhi();   
    }

    }
    else{
    return a.pt() > b.pt();
      }
  }

bool l1t::operator>	(	const l1t::EGamma &	a,
		const l1t::EGamma &	b
	)

Definition at line 18 of file Stage2Layer2EGammaAlgorithmFirmwareImp1.cc.

References reco::LeafCandidate::pt().

  {
      return a.pt() > b.pt();
  }

bool l1t::operator> ( l1t::Tau &  a, l1t::Tau &  b  )

inline

Definition at line 18 of file Stage2Layer2DemuxTauAlgoFirmwareImp1.cc.

References l1t::L1Candidate::hwEta(), l1t::L1Candidate::hwPhi(), and reco::LeafCandidate::pt().

  {
    if ( a.pt() == b.pt() ){
      if( a.hwPhi() == b.hwPhi() ){
    return a.hwEta() > b.hwEta();
      }
      else{
      return a.hwPhi() > b.hwPhi();   
    }

    }
    else{
    return a.pt() > b.pt();
      }
  }

bool l1t::operator>	(	const l1t::Jet &	a,
		const l1t::Jet &	b
	)

Definition at line 22 of file Stage2Layer2JetAlgorithmFirmwareImp1.cc.

References constexpr, and l1t::L1Candidate::hwPt().

                                                       {
    return  a.hwPt() > b.hwPt();
  }

bool l1t::operator>	(	const l1t::Jet &	a,
		l1t::Jet &	b
	)

Definition at line 45 of file L1TStage2CaloLayer2Comp.cc.

References l1t::L1Candidate::hwPt().

                                                 {
    return  a.hwPt() > b.hwPt();
  }

bool l1t::operator>	(	const l1t::EGamma &	a,
		l1t::EGamma &	b
	)

Definition at line 48 of file L1TStage2CaloLayer2Comp.cc.

References l1t::L1Candidate::hwPt().

                                                       {
    return  a.hwPt() > b.hwPt();
  }

bool l1t::operator>	(	const l1t::Tau &	a,
		l1t::Tau &	b
	)

Definition at line 51 of file L1TStage2CaloLayer2Comp.cc.

References l1t::L1Candidate::hwPt().

                                                 {
    return  a.hwPt() > b.hwPt();
  }

unsigned int l1t::pack15bits	(	int	pt,
		int	eta,
		int	phi
	)

Definition at line 21 of file HardwareSortingMethods.cc.

  {
    return( ((pt & 0x3f)) + ((eta & 0xf) << 6) + ((phi & 0x1f) << 10));
  }

unsigned int l1t::pack16bits	(	int	pt,
		int	eta,
		int	phi
	)

Definition at line 26 of file HardwareSortingMethods.cc.

  {
    return( 0x8000 + ((pt & 0x3f)) + ((eta & 0xf) << 6) + ((phi & 0x1f) << 10));
  }

unsigned int l1t::pack16bitsEgammaSpecial	(	int	pt,
		int	eta,
		int	phi
	)

Definition at line 31 of file HardwareSortingMethods.cc.

  {
    return( 0x8000 + ((pt & 0x3f) << 9) + ((eta & 0xf)) + ((phi & 0x1f) << 4));
  }

void l1t::passThroughJets	(	const std::vector< l1t::CaloRegion > *	regions,
		std::vector< l1t::Jet > *	uncalibjets
	)

Definition at line 30 of file JetFinderMethods.cc.

References reco::btau::jetEta, and reco::btau::jetPhi.

  {
    for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
      int jetQual = 0;
      if( region->hwEta() < 4 || region->hwEta() > 17)
    jetQual = 2;
      int jetET = region->hwPt();
      int jetEta = region->hwEta();
      int jetPhi = region->hwPhi();

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
      l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
      uncalibjets->push_back(theJet);
    }
  }

void l1t::RegionCorrection	(	const std::vector< l1t::CaloRegion > &	regions,
		std::vector< l1t::CaloRegion > *	subRegions,
		CaloParamsHelper const *	params
	)

------— New region correction (PUsub, no response correction at the moment) --------—

Definition at line 77 of file PUSubtractionMethods.cc.

References HICaloRingSubtraction(), createfilelist::int, SiStripPI::max, l1t::CaloParamsHelper::regionPUSType(), l1t::CaloParamsHelper::regionPUSValue(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by l1t::Stage1Layer2EGammaAlgorithmImpPP::processEvent(), l1t::Stage1Layer2EtSumAlgorithmImpPP::processEvent(), l1t::Stage1Layer2TauAlgorithmImpPP::processEvent(), l1t::Stage1Layer2JetAlgorithmImpPP::processEvent(), l1t::Stage1Layer2EtSumAlgorithmImpHW::processEvent(), l1t::Stage1Layer2JetAlgorithmImpSimpleHW::processEvent(), l1t::Stage1Layer2TauAlgorithmImpHW::processEvent(), and l1t::Stage1Layer2EGammaAlgorithmImpHW::processEvent().

  {

    std::string regionPUSType = params->regionPUSType();

    if(regionPUSType == "None") {
      for(std::vector<CaloRegion>::const_iterator notCorrectedRegion = regions.begin();
      notCorrectedRegion != regions.end(); notCorrectedRegion++){
    CaloRegion newSubRegion= *notCorrectedRegion;
    subRegions->push_back(newSubRegion);
      }
    }

    if (regionPUSType == "HICaloRingSub") {
      HICaloRingSubtraction(regions, subRegions, params);
    }

    if (regionPUSType == "PUM0") {
      int puMult = 0;

      // ------------ This calulates PUM0 ------------------
      for(std::vector<CaloRegion>::const_iterator notCorrectedRegion = regions.begin();
      notCorrectedRegion != regions.end(); notCorrectedRegion++){
    int regionET = notCorrectedRegion->hwPt();
    if (regionET > 0) {puMult++;}
      }
      int pumbin = (int) puMult/22;
      if(pumbin == 18) pumbin = 17; // if puMult = 396 exactly there is an overflow

      for(std::vector<CaloRegion>::const_iterator notCorrectedRegion = regions.begin();
      notCorrectedRegion != regions.end(); notCorrectedRegion++){

    int regionET = notCorrectedRegion->hwPt();
    int regionEta = notCorrectedRegion->hwEta();
    int regionPhi = notCorrectedRegion->hwPhi();

    //int puSub = ceil(regionPUSParams[18*regionEta+pumbin]*2);
    int puSub = params->regionPUSValue(pumbin, regionEta);
    // The values in regionSubtraction are MULTIPLIED by
    // RegionLSB=.5 (physicalRegionEt), so to get back unmultiplied
    // regionSubtraction we want to multiply the number by 2
    // (aka divide by LSB).

    int regionEtCorr = std::max(0, regionET - puSub);
    if(regionET == 1023)
      regionEtCorr = 1023; // do not subtract overflow regions
    if((regionET==255) && (regionEta < 4 || regionEta > 17))
      regionEtCorr = 255;

    ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > lorentz(0,0,0,0);
    CaloRegion newSubRegion(*&lorentz, 0, 0, regionEtCorr, regionEta, regionPhi, notCorrectedRegion->hwQual(), notCorrectedRegion->hwEtEm(), notCorrectedRegion->hwEtHad());
    subRegions->push_back(newSubRegion);
      }
    }
  }

void l1t::simpleHWSubtraction	(	const std::vector< l1t::CaloRegion > &	regions,
		std::vector< l1t::CaloRegion > *	subRegions
	)

Definition at line 54 of file PUSubtractionMethods.cc.

  {
    for(std::vector<CaloRegion>::const_iterator region = regions.begin();
    region != regions.end(); region++){
      int subEta = region->hwEta();
      int subPhi = region->hwPhi();
      int subPt = region->hwPt();

      if(subPt != (2<<10)-1)
    subPt = subPt - (10+subEta); // arbitrary value chosen in meeting
      if(subPt < 0)
    subPt = 0;
      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      CaloRegion newSubRegion(*&ldummy, 0, 0, subPt, subEta, subPhi, region->hwQual(), region->hwEtEm(), region->hwEtHad());
      subRegions->push_back(newSubRegion);
    }
  }

void l1t::slidingWindowJetFinder	(	const int	jetSeedThreshold,
		const std::vector< l1t::CaloRegion > *	regions,
		std::vector< l1t::Jet > *	uncalibjets
	)

Definition at line 47 of file JetFinderMethods.cc.

References gather_cfg::cout, deltaGctPhi(), reco::btau::jetEta, and reco::btau::jetPhi.

Referenced by l1t::Stage1Layer2EtSumAlgorithmImpPP::processEvent(), l1t::Stage1Layer2JetAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2JetAlgorithmImpSimpleHW::processEvent().

  {
    for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
      int regionET = region->hwPt(); //regionPhysicalEt(*region);
      if (regionET  <= jetSeedThreshold) continue;
      int neighborN_et = 0;
      int neighborS_et = 0;
      int neighborE_et = 0;
      int neighborW_et = 0;
      int neighborNE_et = 0;
      int neighborSW_et = 0;
      int neighborNW_et = 0;
      int neighborSE_et = 0;
      unsigned int nNeighbors = 0;
      for(std::vector<CaloRegion>::const_iterator neighbor = regions->begin(); neighbor != regions->end(); neighbor++) {
    int neighborET = neighbor->hwPt(); //regionPhysicalEt(*neighbor);
    if(deltaGctPhi(*region, *neighbor) == 1 &&
       (region->hwEta()    ) == neighbor->hwEta()) {
      neighborN_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta()    ) == neighbor->hwEta()) {
      neighborS_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborNE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborSW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborNW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborSE_et = neighborET;
      nNeighbors++;
      continue;
    }
      }
      if(regionET > neighborN_et &&
     regionET > neighborNW_et &&
     regionET > neighborW_et &&
     regionET > neighborSW_et &&
     regionET >= neighborNE_et &&
     regionET >= neighborE_et &&
     regionET >= neighborSE_et &&
     regionET >= neighborS_et) {
    unsigned int jetET = regionET +
      neighborN_et + neighborS_et + neighborE_et + neighborW_et +
      neighborNE_et + neighborSW_et + neighborSE_et + neighborNW_et;

    int jetPhi = region->hwPhi();
    int jetEta = region->hwEta();

    bool neighborCheck = (nNeighbors == 8);
    // On the eta edge we only expect 5 neighbors
    if (!neighborCheck && (jetEta == 0 || jetEta == 21) && nNeighbors == 5)
      neighborCheck = true;

    if (!neighborCheck) {
      std::cout << "phi: " << jetPhi << " eta: " << jetEta << " n: " << nNeighbors << std::endl;
      assert(false);
    }

    //first iteration, eta cut defines forward
    //const bool forward = (jetEta <= 4 || jetEta >= 17);
    const bool forward = (jetEta < 4 || jetEta > 17);
    int jetQual = 0;
    if(forward)
      jetQual |= 0x2;

    // check for input overflow regions
    if(forward && regionET == 255) {
      jetET = 1023; // 10 bit max
    } else if(!forward && regionET == 1023) {
      jetET = 1023; // 10 bit max
    } else if(region->hwEta() == 17) {
      if(neighborNE_et == 255 || neighborE_et == 255 || neighborSE_et == 255)
        jetET = 1023; // 10 bit max
    } else if(region->hwEta() == 4) {
      if(neighborNW_et == 255 || neighborW_et == 255 || neighborSW_et == 255)
        jetET = 1023; // 10 bit max
    }

    ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
    l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
    //l1t::Jet theJet(0, jetET, jetEta, jetPhi);

    uncalibjets->push_back(theJet);
      }
    }
  }

void l1t::SortEGammas	(	std::vector< l1t::EGamma > *	input,
		std::vector< l1t::EGamma > *	output
	)

Definition at line 393 of file HardwareSortingMethods.cc.

References mps_fire::i, createfilelist::int, gen::k, reco::HaloData::minus, presort_egamma(), alignCSCRings::r, l1t::L1Candidate::setHwEta(), l1t::L1Candidate::setHwPhi(), l1t::L1Candidate::setHwPt(), l1t::L1Candidate::setHwQual(), sort_by_row_in_groups(), super_sort_matrix_rows(), and tmp.

Referenced by l1t::Stage1Layer2EGammaAlgorithmImpPP::processEvent(), l1t::Stage1Layer2EGammaAlgorithmImpHI::processEvent(), and l1t::Stage1Layer2EGammaAlgorithmImpHW::processEvent().

  {
    //Initialize
    const int FIBER_PAIRS = 18;
    const int N_INPUT_EGAMMAS = 4;
    const int N_PRESORTED_ROWS_EGAMMA = 36;
    const int PRESORT_DEPTH = 4;
    const int N_EGAMMA_FIRST_GROUP_SIZE = 6;
    const int N_EGAMMA_SECOND_GROUP_SIZE = 6;
    const int N_EGAMMA_FIRST_GROUPS = 6;
    const int N_KEEP_EGAMMA = 4;

    //Input
    //Each egamma: RCT isolation, RCT order, phi index, eta index

    vector<l1t::L1Candidate> iso_egamma_array_p, iso_egamma_array_m; //reusing objects.  should probably rename to something like "object"
    vector<l1t::L1Candidate> noniso_egamma_array_p, noniso_egamma_array_m;

    for(int k=0; k<2*N_INPUT_EGAMMAS*FIBER_PAIRS; k++){
      l1t::L1Candidate dummyJet;
      dummyJet.setHwPt(0);
      dummyJet.setHwEta(99);
      dummyJet.setHwPhi(99);
      dummyJet.setHwQual(0x10);
      if(k<N_INPUT_EGAMMAS*FIBER_PAIRS){
    iso_egamma_array_p.push_back(dummyJet);
    noniso_egamma_array_p.push_back(dummyJet);
      }
      else{
    iso_egamma_array_m.push_back(dummyJet);
    noniso_egamma_array_m.push_back(dummyJet);
      }
    }

    for (std::vector<l1t::EGamma>::const_iterator ineg = input->begin();
     ineg != input->end(); ++ineg){
      int fiberNum = (int) floor(gt_to_fw_phi_map[ineg->hwPhi()]/2);
      int index = ineg->hwQual();
      bool iso = ineg->hwIso();
      bool minus = (ineg->hwEta() < 11);

      // while waiting for firmware LUT, set all iso to true
      //iso = true;

      if(iso && minus)
    iso_egamma_array_m[8*fiberNum+index] = *ineg;
      else if (iso && !minus)
    iso_egamma_array_p[8*fiberNum+index] = *ineg;
      else if (!iso && minus)
    noniso_egamma_array_m[8*fiberNum+index] = *ineg;
      else if (!iso && !minus)
    noniso_egamma_array_p[8*fiberNum+index] = *ineg;

    }

    // std::cout << "iso_egamma_array_m" << std::endl;
    // for(int i = 0; i < (int)iso_egamma_array_m.size(); ++i)
    // {
    //   std::cout << iso_egamma_array_m[i].hwPt() << " "
    //     << iso_egamma_array_m[i].hwEta() << " "
    //     << iso_egamma_array_m[i].hwPhi() << std::endl;
    // }

    // std::cout << "iso_egamma_array_p" << std::endl;
    // for(int i = 0; i < (int)iso_egamma_array_p.size(); ++i)
    // {
    //   std::cout << iso_egamma_array_p[i].hwPt() << " "
    //     << iso_egamma_array_p[i].hwEta() << " "
    //     << iso_egamma_array_p[i].hwPhi() << std::endl;
    // }

    //verbose = true;
    //1
    std::vector<std::vector<l1t::L1Candidate> > presorted_iso_matrix_sig_p = presort_egamma(iso_egamma_array_p, N_PRESORTED_ROWS_EGAMMA/2, PRESORT_DEPTH);
    std::vector<std::vector<l1t::L1Candidate> > presorted_iso_matrix_sig_m = presort_egamma(iso_egamma_array_m, N_PRESORTED_ROWS_EGAMMA/2, PRESORT_DEPTH);
    std::vector<std::vector<l1t::L1Candidate> > presorted_non_iso_matrix_sig_p = presort_egamma(noniso_egamma_array_p, N_PRESORTED_ROWS_EGAMMA/2, PRESORT_DEPTH);
    std::vector<std::vector<l1t::L1Candidate> > presorted_non_iso_matrix_sig_m = presort_egamma(noniso_egamma_array_m, N_PRESORTED_ROWS_EGAMMA/2, PRESORT_DEPTH);

    //2
    std::vector<std::vector<l1t::L1Candidate> > iso_row_presorted_energies_matrix_sig_p = sort_by_row_in_groups(presorted_iso_matrix_sig_p, N_EGAMMA_FIRST_GROUP_SIZE);
    std::vector<std::vector<l1t::L1Candidate> > iso_row_presorted_energies_matrix_sig_m = sort_by_row_in_groups(presorted_iso_matrix_sig_m, N_EGAMMA_FIRST_GROUP_SIZE);
    std::vector<std::vector<l1t::L1Candidate> > non_iso_row_presorted_energies_matrix_sig_p = sort_by_row_in_groups(presorted_non_iso_matrix_sig_p, N_EGAMMA_FIRST_GROUP_SIZE);
    std::vector<std::vector<l1t::L1Candidate> > non_iso_row_presorted_energies_matrix_sig_m = sort_by_row_in_groups(presorted_non_iso_matrix_sig_m, N_EGAMMA_FIRST_GROUP_SIZE);

    //3
    std::vector<std::vector<l1t::L1Candidate> > iso_super_sorted_energies_matrix_sig_p = super_sort_matrix_rows(iso_row_presorted_energies_matrix_sig_p, N_EGAMMA_FIRST_GROUP_SIZE, N_KEEP_EGAMMA);
    std::vector<std::vector<l1t::L1Candidate> > iso_super_sorted_energies_matrix_sig_m = super_sort_matrix_rows(iso_row_presorted_energies_matrix_sig_m, N_EGAMMA_FIRST_GROUP_SIZE, N_KEEP_EGAMMA);
    std::vector<std::vector<l1t::L1Candidate> > non_iso_super_sorted_energies_matrix_sig_p = super_sort_matrix_rows(non_iso_row_presorted_energies_matrix_sig_p, N_EGAMMA_FIRST_GROUP_SIZE, N_KEEP_EGAMMA);
    std::vector<std::vector<l1t::L1Candidate> > non_iso_super_sorted_energies_matrix_sig_m = super_sort_matrix_rows(non_iso_row_presorted_energies_matrix_sig_m, N_EGAMMA_FIRST_GROUP_SIZE, N_KEEP_EGAMMA);
    //combine plus and minus
    std::vector<std::vector<l1t::L1Candidate> > iso_super_sorted_energies_matrix_sig (N_EGAMMA_FIRST_GROUPS, std::vector<l1t::L1Candidate>(N_KEEP_EGAMMA) );
    std::vector<std::vector<l1t::L1Candidate> > non_iso_super_sorted_energies_matrix_sig (N_EGAMMA_FIRST_GROUPS, std::vector<l1t::L1Candidate>(N_KEEP_EGAMMA) );
    for(int r=0; r<N_EGAMMA_FIRST_GROUPS/2; r++){
      iso_super_sorted_energies_matrix_sig[r] = iso_super_sorted_energies_matrix_sig_m[r];
      iso_super_sorted_energies_matrix_sig[r+N_EGAMMA_FIRST_GROUPS/2] = iso_super_sorted_energies_matrix_sig_p[r];
      non_iso_super_sorted_energies_matrix_sig[r] = non_iso_super_sorted_energies_matrix_sig_m[r];
      non_iso_super_sorted_energies_matrix_sig[r+N_EGAMMA_FIRST_GROUPS/2] = non_iso_super_sorted_energies_matrix_sig_p[r];
    }

    //4
    std::vector<std::vector<l1t::L1Candidate> > iso_stage2_row_sorted_matrix_sig = sort_by_row_in_groups(iso_super_sorted_energies_matrix_sig, N_EGAMMA_SECOND_GROUP_SIZE);
    std::vector<std::vector<l1t::L1Candidate> > non_iso_stage2_row_sorted_matrix_sig = sort_by_row_in_groups(non_iso_super_sorted_energies_matrix_sig, N_EGAMMA_SECOND_GROUP_SIZE);

    //5
    std::vector<std::vector<l1t::L1Candidate> > iso_stage2_super_sorted_matrix_sig = super_sort_matrix_rows(iso_stage2_row_sorted_matrix_sig, N_EGAMMA_SECOND_GROUP_SIZE, N_KEEP_EGAMMA);
    std::vector<std::vector<l1t::L1Candidate> > non_iso_stage2_super_sorted_matrix_sig = super_sort_matrix_rows(non_iso_stage2_row_sorted_matrix_sig, N_EGAMMA_SECOND_GROUP_SIZE, N_KEEP_EGAMMA);

    //Prepare output
    std::vector<l1t::L1Candidate> sorted_iso_egammas = iso_stage2_super_sorted_matrix_sig[0];
    std::vector<l1t::L1Candidate> sorted_noniso_egammas = non_iso_stage2_super_sorted_matrix_sig[0];

    //verbose = false;

    for(unsigned int i = 0; i < 4; ++i)
    {
      auto const& tmp = sorted_iso_egammas[i];
      output->emplace_back(tmp.p4(), tmp.hwPt(), tmp.hwEta(), tmp.hwPhi(), tmp.hwQual(), 1 /*Iso*/);
    }
    for(unsigned int i = 0; i < 4; ++i)
    {
      auto const& tmp =sorted_noniso_egammas[i];
      output->emplace_back(tmp.p4(),tmp.hwPt(), tmp.hwEta(), tmp.hwPhi(), tmp.hwQual(), tmp.hwIso());
    }
  }

void l1t::SortJets	(	std::vector< l1t::Jet > *	input,
		std::vector< l1t::Jet > *	output
	)

Definition at line 260 of file HardwareSortingMethods.cc.

References mps_fire::i, presort(), sort_by_row_in_groups(), super_sort_matrix_rows(), and tmp.

Referenced by l1t::Stage1Layer2JetAlgorithmImpHI::processEvent(), l1t::Stage1Layer2EtSumAlgorithmImpPP::processEvent(), l1t::Stage1Layer2JetAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2JetAlgorithmImpSimpleHW::processEvent().

                                   {
    //verbose = true;
    const int CENTRAL_ETA_SLICES = 14;
    const int N_PHI_GROUPS = 5;
    const int N_PRESORTED_ROWS_CENTRAL = CENTRAL_ETA_SLICES*N_PHI_GROUPS;
    const int PRESORT_DEPTH = 4;
    const int N_KEEP_CENTRAL = 4;
    const int N_ETA_GROUP_SIZE_CENTRAL = 4;
    const int N_ETA_GROUPS_CENTRAL = 4;

    const int HFM_ETA_SLICES = 4;
    const int HFP_ETA_SLICES = 4;
    const int N_PRESORTED_ROWS_HFM = HFM_ETA_SLICES*N_PHI_GROUPS;
    const int N_PRESORTED_ROWS_HFP = HFP_ETA_SLICES*N_PHI_GROUPS;
    const int N_KEEP_FORWARD = 4;

    const int cen_nrows = 18;
    const int cen_ncols = 14;
    const int hfm_nrows = 18, hfp_nrows = 18;
    const int hfm_ncols = 4, hfp_ncols = 4;

    std::vector<std::vector<l1t::L1Candidate> > cen_input_energy (cen_nrows, std::vector<l1t::L1Candidate>(cen_ncols));
    std::vector<std::vector<l1t::L1Candidate> > hfm_input_energy (hfm_nrows, std::vector<l1t::L1Candidate>(hfm_ncols));
    std::vector<std::vector<l1t::L1Candidate> > hfp_input_energy (hfp_nrows, std::vector<l1t::L1Candidate>(hfp_ncols));

    for (std::vector<l1t::Jet>::const_iterator injet = input->begin();
     injet != input->end(); ++injet){
      if(injet->hwEta() >= 4 && injet->hwEta() <= 17 )
      {
    unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
    unsigned int mycol = injet->hwEta()-4; //hardcoding is bad
    cen_input_energy[myrow][mycol] = *injet;
      }
      else if(injet->hwEta() < 4)
      {
    unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
    unsigned int mycol = injet->hwEta(); //hardcoding is bad
    hfm_input_energy[myrow][mycol] = *injet;
      }
      else if(injet->hwEta() > 17)
      {
    unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
    unsigned int mycol = injet->hwEta()-18; //hardcoding is bad
    hfp_input_energy[myrow][mycol] = *injet;
      }
      else
    edm::LogError("HardwareJetSort") << "Region out of bounds: " << injet->hwEta();
    }

    for(int i = 0; i < cen_nrows; ++i)
      for(int j = 0; j < cen_ncols; ++j)
      {
    if(cen_input_energy[i][j].hwPt() == 0)
    {
      cen_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
      cen_input_energy[i][j].setHwEta(4+j);
    }
      }

    for(int i = 0; i < hfm_nrows; ++i)
      for(int j = 0; j < hfm_ncols; ++j)
      {
    if(hfm_input_energy[i][j].hwPt() == 0)
    {
      hfm_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
      hfm_input_energy[i][j].setHwEta(j);
      hfm_input_energy[i][j].setHwQual(2);
    }
      }

    for(int i = 0; i < hfp_nrows; ++i)
      for(int j = 0; j < hfp_ncols; ++j)
      {
    if(hfp_input_energy[i][j].hwPt() == 0)
    {
      hfp_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
      hfp_input_energy[i][j].setHwEta(j+18);
      hfp_input_energy[i][j].setHwQual(2);
    }
      }

    //Each CLK is one clock

    //CLK 1
    std::vector<std::vector<l1t::L1Candidate> > presorted_energies_matrix_sig = presort(cen_input_energy, N_PRESORTED_ROWS_CENTRAL, PRESORT_DEPTH);
    std::vector<std::vector<l1t::L1Candidate> > hfm_presorted_energies_matrix_sig = presort(hfm_input_energy, N_PRESORTED_ROWS_HFM, PRESORT_DEPTH);
    std::vector<std::vector<l1t::L1Candidate> > hfp_presorted_energies_matrix_sig = presort(hfp_input_energy, N_PRESORTED_ROWS_HFP, PRESORT_DEPTH);

    //CLK 2
    std::vector<std::vector<l1t::L1Candidate> > row_presorted_energies_matrix_sig = sort_by_row_in_groups(presorted_energies_matrix_sig, N_PHI_GROUPS);
    std::vector<std::vector<l1t::L1Candidate> > hfm_row_presorted_energies_matrix_sig = sort_by_row_in_groups(hfm_presorted_energies_matrix_sig, N_PHI_GROUPS);
    std::vector<std::vector<l1t::L1Candidate> > hfp_row_presorted_energies_matrix_sig = sort_by_row_in_groups(hfp_presorted_energies_matrix_sig, N_PHI_GROUPS);

    //CLK 3
    std::vector<std::vector<l1t::L1Candidate> > sorted_eta_slices_energies_matrix_sig = super_sort_matrix_rows(row_presorted_energies_matrix_sig, N_PHI_GROUPS, N_KEEP_CENTRAL);
    std::vector<std::vector<l1t::L1Candidate> > hfm_sorted_eta_slices_energies_matrix_sig = super_sort_matrix_rows(hfm_row_presorted_energies_matrix_sig, N_PHI_GROUPS, N_KEEP_FORWARD);
    std::vector<std::vector<l1t::L1Candidate> > hfp_sorted_eta_slices_energies_matrix_sig = super_sort_matrix_rows(hfp_row_presorted_energies_matrix_sig, N_PHI_GROUPS, N_KEEP_FORWARD);

    //CLK 4
    std::vector<std::vector<l1t::L1Candidate> > row_presorted_eta_slices_energies_matrix_sig = sort_by_row_in_groups(sorted_eta_slices_energies_matrix_sig, N_ETA_GROUP_SIZE_CENTRAL);
    std::vector<std::vector<l1t::L1Candidate> > hfm_row_presorted_eta_slices_energies_matrix_sig = sort_by_row_in_groups(hfm_sorted_eta_slices_energies_matrix_sig, HFM_ETA_SLICES);
    std::vector<std::vector<l1t::L1Candidate> > hfp_row_presorted_eta_slices_energies_matrix_sig = sort_by_row_in_groups(hfp_sorted_eta_slices_energies_matrix_sig, HFP_ETA_SLICES);

    //CLK 5
    std::vector<std::vector<l1t::L1Candidate> > sorted_eta_groups_energies_matrix_sig = super_sort_matrix_rows(row_presorted_eta_slices_energies_matrix_sig, N_ETA_GROUP_SIZE_CENTRAL, N_KEEP_CENTRAL);
    std::vector<std::vector<l1t::L1Candidate> > hfm_sorted_final_energies_matrix_sig = super_sort_matrix_rows(hfm_row_presorted_eta_slices_energies_matrix_sig, HFM_ETA_SLICES, N_KEEP_FORWARD);
    std::vector<std::vector<l1t::L1Candidate> > hfp_sorted_final_energies_matrix_sig = super_sort_matrix_rows(hfp_row_presorted_eta_slices_energies_matrix_sig, HFP_ETA_SLICES, N_KEEP_FORWARD);

    //CLK 6
    std::vector<std::vector<l1t::L1Candidate> > row_presorted_eta_groups_energies_matrix_sig = sort_by_row_in_groups(sorted_eta_groups_energies_matrix_sig, N_ETA_GROUPS_CENTRAL);
    std::vector<std::vector<l1t::L1Candidate> > hf_merged_plus_minus_forward_energies_matrix_sig(2, std::vector<l1t::L1Candidate>(N_KEEP_FORWARD));
    hf_merged_plus_minus_forward_energies_matrix_sig[0] = hfm_sorted_final_energies_matrix_sig[0];
    hf_merged_plus_minus_forward_energies_matrix_sig[1] = hfp_sorted_final_energies_matrix_sig[0];
    std::vector<std::vector<l1t::L1Candidate> > hf_row_presorted_merged_plus_minus_forward_energies_matrix_sig = sort_by_row_in_groups(hf_merged_plus_minus_forward_energies_matrix_sig, 2);

    //CLK 7
    std::vector<std::vector<l1t::L1Candidate> > sorted_final_energies_matrix_sig = super_sort_matrix_rows(row_presorted_eta_groups_energies_matrix_sig, N_ETA_GROUPS_CENTRAL, N_KEEP_CENTRAL);
    std::vector<std::vector<l1t::L1Candidate> > hf_sorted_final_merged_plus_minus_forward_energies_matrix_sig = super_sort_matrix_rows(hf_row_presorted_merged_plus_minus_forward_energies_matrix_sig, 2, N_KEEP_FORWARD);

    for(unsigned int i = 0; i < 4; ++i)
    {
      auto const& tmp = sorted_final_energies_matrix_sig[0][i];
      output->emplace_back( tmp.p4(), tmp.hwPt(), tmp.hwEta(), tmp.hwPhi(), tmp.hwQual() );
    }
    for(unsigned int i = 0; i < 4; ++i)
    {
      auto const& tmp = hf_sorted_final_merged_plus_minus_forward_energies_matrix_sig[0][i];
      output->emplace_back(tmp.p4(), tmp.hwPt(), tmp.hwEta(), tmp.hwPhi(), tmp.hwQual() | 2 );
    }
    //verbose = false;
  }

void l1t::SortTaus	(	std::vector< l1t::Tau > *	input,
		std::vector< l1t::Tau > *	output
	)

Definition at line 519 of file HardwareSortingMethods.cc.

References mps_fire::i, presort(), sort_by_row_in_groups(), super_sort_matrix_rows(), and tmp.

Referenced by l1t::Stage1Layer2SingleTrackHI::processEvent(), l1t::Stage1Layer2TauAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2TauAlgorithmImpHW::processEvent().

                                   {
    const int CENTRAL_ETA_SLICES = 14;
    const int N_PHI_GROUPS = 5;
    const int N_PRESORTED_ROWS_CENTRAL = CENTRAL_ETA_SLICES*N_PHI_GROUPS;
    const int PRESORT_DEPTH = 4;
    const int N_KEEP_CENTRAL = 4;
    const int N_ETA_GROUP_SIZE_CENTRAL = 4;
    const int N_ETA_GROUPS_CENTRAL = 4;

    const int cen_nrows = 18;
    const int cen_ncols = 14;

    std::vector<std::vector<l1t::L1Candidate> > cen_input_energy (cen_nrows, std::vector<l1t::L1Candidate>(cen_ncols));

    for (std::vector<l1t::Tau>::const_iterator injet = input->begin();
     injet != input->end(); ++injet){
      if(injet->hwEta() >= 4 && injet->hwEta() <= 17 )
      {
    unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
    unsigned int mycol = injet->hwEta()-4; //hardcoding is bad
    cen_input_energy[myrow][mycol] = *injet;
      }
      else
    edm::LogError("HardwareTauSort") << "Region out of bounds: " << injet->hwEta();
    }

    for(int i = 0; i < cen_nrows; ++i)
      for(int j = 0; j < cen_ncols; ++j)
      {
    if(cen_input_energy[i][j].hwPt() == 0)
    {
      cen_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
      cen_input_energy[i][j].setHwEta(4+j);
    }
      }

    //Each CLK is one clock

    //CLK 1
    std::vector<std::vector<l1t::L1Candidate> > presorted_energies_matrix_sig = presort(cen_input_energy, N_PRESORTED_ROWS_CENTRAL, PRESORT_DEPTH);
    //CLK 2
    std::vector<std::vector<l1t::L1Candidate> > row_presorted_energies_matrix_sig = sort_by_row_in_groups(presorted_energies_matrix_sig, N_PHI_GROUPS);
    //CLK 3
    std::vector<std::vector<l1t::L1Candidate> > sorted_eta_slices_energies_matrix_sig = super_sort_matrix_rows(row_presorted_energies_matrix_sig, N_PHI_GROUPS, N_KEEP_CENTRAL);
    //CLK 4
    std::vector<std::vector<l1t::L1Candidate> > row_presorted_eta_slices_energies_matrix_sig = sort_by_row_in_groups(sorted_eta_slices_energies_matrix_sig, N_ETA_GROUP_SIZE_CENTRAL);
    //CLK 5
    std::vector<std::vector<l1t::L1Candidate> > sorted_eta_groups_energies_matrix_sig = super_sort_matrix_rows(row_presorted_eta_slices_energies_matrix_sig, N_ETA_GROUP_SIZE_CENTRAL, N_KEEP_CENTRAL);
    //CLK 6
    std::vector<std::vector<l1t::L1Candidate> > row_presorted_eta_groups_energies_matrix_sig = sort_by_row_in_groups(sorted_eta_groups_energies_matrix_sig, N_ETA_GROUPS_CENTRAL);
    //CLK 7
    std::vector<std::vector<l1t::L1Candidate> > sorted_final_energies_matrix_sig = super_sort_matrix_rows(row_presorted_eta_groups_energies_matrix_sig, N_ETA_GROUPS_CENTRAL, N_KEEP_CENTRAL);

    for(unsigned int i = 0; i < 4; ++i)
    {
      auto const& tmp = sorted_final_energies_matrix_sig[0][i];
      output->emplace_back(tmp.p4(), tmp.hwPt(), tmp.hwEta(), tmp.hwPhi(), tmp.hwQual(), tmp.hwIso());
    }
  }

void l1t::TauToGtEtaScales	(	CaloParamsHelper const *	params,
		const std::vector< l1t::Tau > *	input,
		std::vector< l1t::Tau > *	output
	)

Definition at line 124 of file legacyGtHelper.cc.

References gtEta(), and gtTau.

Referenced by l1t::Stage1Layer2SingleTrackHI::processEvent(), l1t::Stage1Layer2TauAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2TauAlgorithmImpHW::processEvent().

                                      {
    for(std::vector<l1t::Tau>::const_iterator itTau = input->begin();
    itTau != input->end(); ++itTau){
      unsigned newPhi = itTau->hwPhi();
      unsigned newEta = gtEta(itTau->hwEta());

      // taus with hwQual & 10 ==10 are "padding" jets from a sort, set their eta and phi
      // to the max value
      if((itTau->hwQual() & 0x10) == 0x10)
      {
    newEta = 0x0;
    newPhi = 0x0;
      }


      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::Tau gtTau(*&ldummy, itTau->hwPt(), newEta, newPhi, itTau->hwQual(), itTau->hwIso());
      output->push_back(gtTau);
    }
  }

void l1t::TauToGtPtScales	(	CaloParamsHelper const *	params,
		const std::vector< l1t::Tau > *	input,
		std::vector< l1t::Tau > *	output
	)

Definition at line 148 of file legacyGtHelper.cc.

References gtTau, l1t::CaloParamsHelper::jetScale(), L1CaloEtScale::linScaleMax(), and L1CaloEtScale::rank().

Referenced by l1t::Stage1Layer2SingleTrackHI::processEvent(), and l1t::Stage1Layer2TauAlgorithmImpPP::processEvent().

                                         {
    for(std::vector<l1t::Tau>::const_iterator itTau = input->begin();
    itTau != input->end(); ++itTau){
      uint16_t linPt = (uint16_t)itTau->hwPt();
      if(linPt > params->jetScale().linScaleMax() ) linPt = params->jetScale().linScaleMax();
      const uint16_t rankPt = params->jetScale().rank(linPt);

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::Tau gtTau(*&ldummy, rankPt, itTau->hwEta(), itTau->hwPhi(), itTau->hwQual(), itTau->hwIso());
      output->push_back(gtTau);
    }
  }

void l1t::TwelveByTwelveFinder	(	const int	jetSeedThreshold,
		const std::vector< l1t::CaloRegion > *	regions,
		std::vector< l1t::Jet > *	uncalibjets
	)

Definition at line 168 of file JetFinderMethods.cc.

References gather_cfg::cout, deltaGctPhi(), reco::btau::jetEta, and reco::btau::jetPhi.

Referenced by l1t::Stage1Layer2EGammaAlgorithmImpPP::processEvent(), l1t::Stage1Layer2TauAlgorithmImpPP::processEvent(), l1t::Stage1Layer2TauAlgorithmImpHW::processEvent(), and l1t::Stage1Layer2EGammaAlgorithmImpHW::processEvent().

  {
    for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
      int regionET = region->hwPt(); //regionPhysicalEt(*region);
      if (regionET  < jetSeedThreshold) continue;
      int neighborN_et = 0;
      int neighborS_et = 0;
      int neighborE_et = 0;
      int neighborW_et = 0;
      int neighborNE_et = 0;
      int neighborSW_et = 0;
      int neighborNW_et = 0;
      int neighborSE_et = 0;
      unsigned int nNeighbors = 0;
      for(std::vector<CaloRegion>::const_iterator neighbor = regions->begin(); neighbor != regions->end(); neighbor++) {
    int neighborET = neighbor->hwPt(); //regionPhysicalEt(*neighbor);
    if(deltaGctPhi(*region, *neighbor) == 1 &&
       (region->hwEta()    ) == neighbor->hwEta()) {
      neighborN_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta()    ) == neighbor->hwEta()) {
      neighborS_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborNE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborSW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborNW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborSE_et = neighborET;
      nNeighbors++;
      continue;
    }
      }
      unsigned int jetET = regionET +
    neighborN_et + neighborS_et + neighborE_et + neighborW_et +
    neighborNE_et + neighborSW_et + neighborSE_et + neighborNW_et;

      int jetPhi = region->hwPhi();
      int jetEta = region->hwEta();

      bool neighborCheck = (nNeighbors == 8);
      // On the eta edge we only expect 5 neighbors
      if (!neighborCheck && (jetEta == 0 || jetEta == 21) && nNeighbors == 5)
    neighborCheck = true;

      if (!neighborCheck) {
    std::cout << "phi: " << jetPhi << " eta: " << jetEta << " n: " << nNeighbors << std::endl;
    assert(false);
      }

      //first iteration, eta cut defines forward
      //const bool forward = (jetEta <= 4 || jetEta >= 17);
      const bool forward = (jetEta < 4 || jetEta > 17);
      int jetQual = 0;
      if(forward)
    jetQual |= 0x2;

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
      l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
      //l1t::Jet theJet(0, jetET, jetEta, jetPhi);

      uncalibjets->push_back(theJet);
    }
  }

void l1t::TwoByTwoFinder	(	const int	jetSeedThreshold,
		const int	etaMask,
		const std::vector< l1t::CaloRegion > *	regions,
		std::vector< l1t::Jet > *	uncalibjets
	)

Definition at line 267 of file JetFinderMethods.cc.

References gather_cfg::cout, deltaGctPhi(), reco::btau::jetEta, reco::btau::jetPhi, and SiStripPI::max.

Referenced by l1t::Stage1Layer2JetAlgorithmImpHI::processEvent().

  {
    for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
      int regionET = region->hwPt();
      if (regionET  <= jetSeedThreshold) continue;
      int subEta = region->hwEta();
      if((etaMask & (1<<subEta))>>subEta) regionET = 0;
      int neighborN_et = 0;
      int neighborS_et = 0;
      int neighborE_et = 0;
      int neighborW_et = 0;
      int neighborNE_et = 0;
      int neighborSW_et = 0;
      int neighborNW_et = 0;
      int neighborSE_et = 0;
      unsigned int nNeighbors = 0;
      for(std::vector<CaloRegion>::const_iterator neighbor = regions->begin(); neighbor != regions->end(); neighbor++) {
    int neighborET = neighbor->hwPt();
    int subEta2 = neighbor->hwEta();
    if((etaMask & (1<<subEta2))>>subEta2) neighborET = 0;

    if(deltaGctPhi(*region, *neighbor) == 1 &&
       (region->hwEta()    ) == neighbor->hwEta()) {
      neighborN_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta()    ) == neighbor->hwEta()) {
      neighborS_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborNE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborSW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborNW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborSE_et = neighborET;
      nNeighbors++;
      continue;
    }

      }
      if(regionET > neighborN_et &&
     regionET > neighborNW_et &&
     regionET > neighborW_et &&
     regionET > neighborSW_et &&
     regionET >= neighborNE_et &&
     regionET >= neighborE_et &&
     regionET >= neighborSE_et &&
     regionET >= neighborS_et) {

    // use the highest-pT 2x2 jet inside this 3x3
    unsigned int jetET_NW;
    unsigned int jetET_NE;
    unsigned int jetET_SW;
    unsigned int jetET_SE;

    jetET_NW = regionET + neighborW_et + neighborNW_et + neighborN_et;
    jetET_NE = regionET + neighborE_et + neighborNE_et + neighborN_et;
    jetET_SW = regionET + neighborS_et + neighborSW_et + neighborW_et;
    jetET_SE = regionET + neighborS_et + neighborSE_et + neighborE_et;

    unsigned int jetET = std::max(jetET_NW, jetET_NE);
    jetET = std::max(jetET, jetET_SW);
    jetET = std::max(jetET, jetET_SE);

    int jetPhi = region->hwPhi();
    int jetEta = region->hwEta();

    bool neighborCheck = (nNeighbors == 8);
    // On the eta edge we only expect 5 neighbor
    if (!neighborCheck && (jetEta == 0 || jetEta == 21) && nNeighbors == 5)
      neighborCheck = true;

    if (!neighborCheck) {
      std::cout << "phi: " << jetPhi << " eta: " << jetEta << " n: " << nNeighbors << std::endl;
      assert(false);
    }

    //first iteration, eta cut defines forward
    const bool forward = (jetEta < 4 || jetEta > 17);
    int jetQual = 0;
    if(forward)
      jetQual |= 0x2;

    ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
    l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
    uncalibjets->push_back(theJet);
      }
    }
  }